]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Warning fix.
[wxWidgets.git] / wxPython / src / msw / _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 static
1591 swig_type_info* wxPyFindSwigType(const wxChar* className);
1592
1593
1594
1595 // Make a SWIGified pointer object suitable for a .this attribute
1596 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1597
1598 PyObject* robj = NULL;
1599
1600 swig_type_info* swigType = wxPyFindSwigType(className);
1601 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
1602
1603 #ifdef SWIG_COBJECT_TYPES
1604 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1605 #else
1606 {
1607 char result[1024];
1608 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1609 PyString_FromString(result) : 0;
1610 }
1611 #endif
1612 return robj;
1613 }
1614
1615
1616 #include <wx/hashmap.h>
1617 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1618
1619
1620 // Maintains a hashmap of className to swig_type_info pointers. Given the
1621 // name of a class either looks up the type info in the cache, or scans the
1622 // SWIG tables for it.
1623 extern PyObject* wxPyPtrTypeMap;
1624 static
1625 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1626
1627 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1628
1629 if (typeInfoCache == NULL)
1630 typeInfoCache = new wxPyTypeInfoHashMap;
1631
1632 wxString name(className);
1633 swig_type_info* swigType = (*typeInfoCache)[name];
1634
1635 if (! swigType) {
1636 // it wasn't in the cache, so look it up from SWIG
1637 name.Append(wxT(" *"));
1638 swigType = SWIG_TypeQuery(name.mb_str());
1639
1640 // if it still wasn't found, try looking for a mapped name
1641 if (!swigType) {
1642 PyObject* item;
1643 name = className;
1644
1645 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1646 (char*)(const char*)name.mbc_str())) != NULL) {
1647 name = wxString(PyString_AsString(item), *wxConvCurrent);
1648 name.Append(wxT(" *"));
1649 swigType = SWIG_TypeQuery(name.mb_str());
1650 }
1651 }
1652 if (swigType) {
1653 // and add it to the map if found
1654 (*typeInfoCache)[className] = swigType;
1655 }
1656 }
1657 return swigType;
1658 }
1659
1660
1661 // Check if a class name is a type known to SWIG
1662 bool wxPyCheckSwigType(const wxChar* className) {
1663
1664 swig_type_info* swigType = wxPyFindSwigType(className);
1665 return swigType != NULL;
1666 }
1667
1668
1669 // Given a pointer to a C++ object and a class name, construct a Python proxy
1670 // object for it.
1671 PyObject* wxPyConstructObject(void* ptr,
1672 const wxChar* className,
1673 int setThisOwn) {
1674
1675 swig_type_info* swigType = wxPyFindSwigType(className);
1676 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1677
1678 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1679 }
1680
1681
1682 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1683 // Ensures that the proxy object is of the specified (or derived) type. If
1684 // not able to perform the conversion then a Python exception is set and the
1685 // error should be handled properly in the caller. Returns True on success.
1686 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1687 const wxChar* className) {
1688
1689 swig_type_info* swigType = wxPyFindSwigType(className);
1690 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1691
1692 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1693 }
1694
1695
1696
1697
1698 // Python's PyInstance_Check does not return True for instances of new-style
1699 // classes. This should get close enough for both new and old classes but I
1700 // should re-evaluate the need for doing instance checks...
1701 bool wxPyInstance_Check(PyObject* obj) {
1702 return PyObject_HasAttrString(obj, "__class__") != 0;
1703 }
1704
1705
1706
1707 // This one checks if the object is an instance of a SWIG proxy class (it has
1708 // a .this attribute, and the .this attribute is a PySwigObject.)
1709 bool wxPySwigInstance_Check(PyObject* obj) {
1710 static PyObject* this_str = NULL;
1711 if (this_str == NULL)
1712 this_str = PyString_FromString("this");
1713
1714 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1715 if (this_attr) {
1716 bool retval = (PySwigObject_Check(this_attr) != 0);
1717 Py_DECREF(this_attr);
1718 return retval;
1719 }
1720
1721 PyErr_Clear();
1722 return false;
1723 }
1724
1725
1726
1727 // Export a C API in a struct. Other modules will be able to load this from
1728 // the wx._core_ module and will then have safe access to these functions,
1729 // even if they are located in another shared library.
1730 static wxPyCoreAPI API = {
1731
1732 wxPyCheckSwigType,
1733 wxPyConstructObject,
1734 wxPyConvertSwigPtr,
1735 wxPyMakeSwigPtr,
1736
1737 wxPyBeginAllowThreads,
1738 wxPyEndAllowThreads,
1739 wxPyBeginBlockThreads,
1740 wxPyEndBlockThreads,
1741
1742 wxPy_ConvertList,
1743
1744 wxString_in_helper,
1745 Py2wxString,
1746 wx2PyString,
1747
1748 byte_LIST_helper,
1749 int_LIST_helper,
1750 long_LIST_helper,
1751 string_LIST_helper,
1752 wxPoint_LIST_helper,
1753 wxBitmap_LIST_helper,
1754 wxString_LIST_helper,
1755 wxAcceleratorEntry_LIST_helper,
1756
1757 wxSize_helper,
1758 wxPoint_helper,
1759 wxRealPoint_helper,
1760 wxRect_helper,
1761 wxColour_helper,
1762 wxPoint2D_helper,
1763
1764 wxPySimple_typecheck,
1765 wxColour_typecheck,
1766
1767 wxPyCBH_setCallbackInfo,
1768 wxPyCBH_findCallback,
1769 wxPyCBH_callCallback,
1770 wxPyCBH_callCallbackObj,
1771 wxPyCBH_delete,
1772
1773 wxPyMake_wxObject,
1774 wxPyMake_wxSizer,
1775 wxPyPtrTypeMap_Add,
1776 wxPy2int_seq_helper,
1777 wxPy4int_seq_helper,
1778 wxArrayString2PyList_helper,
1779 wxArrayInt2PyList_helper,
1780
1781 wxPyClientData_dtor,
1782 wxPyUserData_dtor,
1783 wxPyOORClientData_dtor,
1784
1785 wxPyCBInputStream_create,
1786 wxPyCBInputStream_copy,
1787
1788 wxPyInstance_Check,
1789 wxPySwigInstance_Check,
1790
1791 wxPyCheckForApp
1792
1793 };
1794
1795 #endif
1796
1797
1798 #if !WXWIN_COMPATIBILITY_2_4
1799 #define wxHIDE_READONLY 0
1800 #endif
1801
1802
1803 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
1804 #define SWIG_From_int PyInt_FromLong
1805 /*@@*/
1806
1807 static const wxString wxPyEmptyString(wxEmptyString);
1808 static wxString wxObject_GetClassName(wxObject *self){
1809 return self->GetClassInfo()->GetClassName();
1810 }
1811 static void wxObject_Destroy(wxObject *self){
1812 delete self;
1813 }
1814
1815 #ifndef __WXMAC__
1816 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1817 #endif
1818
1819
1820 #include <limits.h>
1821
1822
1823 SWIGINTERN int
1824 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1825 const char *errmsg)
1826 {
1827 if (value < min_value) {
1828 if (errmsg) {
1829 PyErr_Format(PyExc_OverflowError,
1830 "value %ld is less than '%s' minimum %ld",
1831 value, errmsg, min_value);
1832 }
1833 return 0;
1834 } else if (value > max_value) {
1835 if (errmsg) {
1836 PyErr_Format(PyExc_OverflowError,
1837 "value %ld is greater than '%s' maximum %ld",
1838 value, errmsg, max_value);
1839 }
1840 return 0;
1841 }
1842 return 1;
1843 }
1844
1845
1846 SWIGINTERN int
1847 SWIG_AsVal_long(PyObject* obj, long* val)
1848 {
1849 if (PyNumber_Check(obj)) {
1850 if (val) *val = PyInt_AsLong(obj);
1851 return 1;
1852 }
1853 else {
1854 SWIG_Python_TypeError("number", obj);
1855 }
1856 return 0;
1857 }
1858
1859
1860 #if INT_MAX != LONG_MAX
1861 SWIGINTERN int
1862 SWIG_AsVal_int(PyObject *obj, int *val)
1863 {
1864 const char* errmsg = val ? "int" : (char*)0;
1865 long v;
1866 if (SWIG_AsVal_long(obj, &v)) {
1867 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1868 if (val) *val = static_cast<int >(v);
1869 return 1;
1870 } else {
1871 return 0;
1872 }
1873 } else {
1874 PyErr_Clear();
1875 }
1876 if (val) {
1877 SWIG_type_error(errmsg, obj);
1878 }
1879 return 0;
1880 }
1881 #else
1882 SWIGINTERNINLINE int
1883 SWIG_AsVal_int(PyObject *obj, int *val)
1884 {
1885 return SWIG_AsVal_long(obj,(long*)val);
1886 }
1887 #endif
1888
1889
1890 SWIGINTERNINLINE int
1891 SWIG_As_int(PyObject* obj)
1892 {
1893 int v;
1894 if (!SWIG_AsVal_int(obj, &v)) {
1895 /*
1896 this is needed to make valgrind/purify happier.
1897 */
1898 memset((void*)&v, 0, sizeof(int));
1899 }
1900 return v;
1901 }
1902
1903
1904 SWIGINTERNINLINE int
1905 SWIG_Check_int(PyObject* obj)
1906 {
1907 return SWIG_AsVal_int(obj, (int*)0);
1908 }
1909
1910 static PyObject *wxSize_Get(wxSize *self){
1911 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1912 PyObject* tup = PyTuple_New(2);
1913 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1914 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1915 wxPyEndBlockThreads(blocked);
1916 return tup;
1917 }
1918
1919 SWIGINTERN int
1920 SWIG_AsVal_double(PyObject *obj, double* val)
1921 {
1922 if (PyNumber_Check(obj)) {
1923 if (val) *val = PyFloat_AsDouble(obj);
1924 return 1;
1925 }
1926 else {
1927 SWIG_Python_TypeError("number", obj);
1928 }
1929 return 0;
1930 }
1931
1932
1933 SWIGINTERNINLINE double
1934 SWIG_As_double(PyObject* obj)
1935 {
1936 double v;
1937 if (!SWIG_AsVal_double(obj, &v)) {
1938 /*
1939 this is needed to make valgrind/purify happier.
1940 */
1941 memset((void*)&v, 0, sizeof(double));
1942 }
1943 return v;
1944 }
1945
1946
1947 SWIGINTERNINLINE int
1948 SWIG_Check_double(PyObject* obj)
1949 {
1950 return SWIG_AsVal_double(obj, (double*)0);
1951 }
1952
1953
1954 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
1955 #define SWIG_From_double PyFloat_FromDouble
1956 /*@@*/
1957
1958 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1959 self->x = x;
1960 self->y = y;
1961 }
1962 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1963 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1964 PyObject* tup = PyTuple_New(2);
1965 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1966 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1967 wxPyEndBlockThreads(blocked);
1968 return tup;
1969 }
1970
1971 SWIGINTERNINLINE long
1972 SWIG_As_long(PyObject* obj)
1973 {
1974 long v;
1975 if (!SWIG_AsVal_long(obj, &v)) {
1976 /*
1977 this is needed to make valgrind/purify happier.
1978 */
1979 memset((void*)&v, 0, sizeof(long));
1980 }
1981 return v;
1982 }
1983
1984
1985 SWIGINTERNINLINE int
1986 SWIG_Check_long(PyObject* obj)
1987 {
1988 return SWIG_AsVal_long(obj, (long*)0);
1989 }
1990
1991 static void wxPoint_Set(wxPoint *self,long x,long y){
1992 self->x = x;
1993 self->y = y;
1994 }
1995 static PyObject *wxPoint_Get(wxPoint *self){
1996 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1997 PyObject* tup = PyTuple_New(2);
1998 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1999 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2000 wxPyEndBlockThreads(blocked);
2001 return tup;
2002 }
2003 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
2004 self->x = x;
2005 self->y = y;
2006 self->width = width;
2007 self->height = height;
2008 }
2009 static PyObject *wxRect_Get(wxRect *self){
2010 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2011 PyObject* tup = PyTuple_New(4);
2012 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2013 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2014 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
2015 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
2016 wxPyEndBlockThreads(blocked);
2017 return tup;
2018 }
2019
2020 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
2021 wxRegion reg1(*r1);
2022 wxRegion reg2(*r2);
2023 wxRect dest(0,0,0,0);
2024 PyObject* obj;
2025
2026 reg1.Intersect(reg2);
2027 dest = reg1.GetBox();
2028
2029 if (dest != wxRect(0,0,0,0)) {
2030 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2031 wxRect* newRect = new wxRect(dest);
2032 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
2033 wxPyEndBlockThreads(blocked);
2034 return obj;
2035 }
2036 Py_INCREF(Py_None);
2037 return Py_None;
2038 }
2039
2040
2041 static PyObject* t_output_helper(PyObject* result, PyObject* obj)
2042 {
2043 PyObject* o2;
2044 PyObject* o3;
2045 if (!result) {
2046 result = obj;
2047 } else if (result == Py_None) {
2048 Py_DECREF(result);
2049 result = obj;
2050 } else {
2051 if (!PyTuple_Check(result)) {
2052 o2 = result;
2053 result = PyTuple_New(1);
2054 PyTuple_SET_ITEM(result, 0, o2);
2055 }
2056 o3 = PyTuple_New(1);
2057 PyTuple_SetItem(o3, 0, obj);
2058 o2 = result;
2059 result = PySequence_Concat(o2, o3);
2060 Py_DECREF(o2);
2061 Py_DECREF(o3);
2062 }
2063 return result;
2064 }
2065
2066
2067 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
2068 self->m_x = x;
2069 self->m_y = y;
2070 }
2071 static PyObject *wxPoint2D_Get(wxPoint2D *self){
2072 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2073 PyObject* tup = PyTuple_New(2);
2074 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
2075 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
2076 wxPyEndBlockThreads(blocked);
2077 return tup;
2078 }
2079
2080 #include "wx/wxPython/pyistream.h"
2081
2082 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
2083 wxInputStream* wxis = wxPyCBInputStream::create(p);
2084 if (wxis)
2085 return new wxPyInputStream(wxis);
2086 else
2087 return NULL;
2088 }
2089
2090 SWIGINTERNINLINE PyObject*
2091 SWIG_From_char(char c)
2092 {
2093 return PyString_FromStringAndSize(&c,1);
2094 }
2095
2096
2097 SWIGINTERNINLINE PyObject*
2098 SWIG_From_unsigned_SS_long(unsigned long value)
2099 {
2100 return (value > LONG_MAX) ?
2101 PyLong_FromUnsignedLong(value)
2102 : PyInt_FromLong(static_cast<long >(value));
2103 }
2104
2105
2106 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2107 SWIGINTERN int
2108 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2109 {
2110 static swig_type_info* pchar_info = 0;
2111 char* vptr = 0;
2112 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2113 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2114 if (cptr) *cptr = vptr;
2115 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2116 return SWIG_OLDOBJ;
2117 } else {
2118 PyErr_Clear();
2119 if (PyString_Check(obj)) {
2120 if (cptr) {
2121 *cptr = PyString_AS_STRING(obj);
2122 if (psize) {
2123 *psize = PyString_GET_SIZE(obj) + 1;
2124 }
2125 }
2126 return SWIG_PYSTR;
2127 }
2128 }
2129 if (cptr) {
2130 SWIG_type_error("char *", obj);
2131 }
2132 return 0;
2133 }
2134
2135
2136 SWIGINTERN int
2137 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2138 {
2139 char* cptr; size_t csize;
2140 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2141 /* in C you can do:
2142
2143 char x[5] = "hello";
2144
2145 ie, assing the array using an extra '0' char.
2146 */
2147 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2148 if (csize <= size) {
2149 if (val) {
2150 if (csize) memcpy(val, cptr, csize);
2151 if (csize < size) memset(val + csize, 0, size - csize);
2152 }
2153 return 1;
2154 }
2155 }
2156 if (val) {
2157 PyErr_Format(PyExc_TypeError,
2158 "a char array of maximum size %lu is expected",
2159 (unsigned long) size);
2160 }
2161 return 0;
2162 }
2163
2164
2165 SWIGINTERN int
2166 SWIG_AsVal_char(PyObject *obj, char *val)
2167 {
2168 const char* errmsg = val ? "char" : (char*)0;
2169 long v;
2170 if (SWIG_AsVal_long(obj, &v)) {
2171 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2172 if (val) *val = static_cast<char >(v);
2173 return 1;
2174 } else {
2175 return 0;
2176 }
2177 } else {
2178 PyErr_Clear();
2179 return SWIG_AsCharArray(obj, val, 1);
2180 }
2181 }
2182
2183
2184 SWIGINTERNINLINE char
2185 SWIG_As_char(PyObject* obj)
2186 {
2187 char v;
2188 if (!SWIG_AsVal_char(obj, &v)) {
2189 /*
2190 this is needed to make valgrind/purify happier.
2191 */
2192 memset((void*)&v, 0, sizeof(char));
2193 }
2194 return v;
2195 }
2196
2197
2198 SWIGINTERNINLINE int
2199 SWIG_Check_char(PyObject* obj)
2200 {
2201 return SWIG_AsVal_char(obj, (char*)0);
2202 }
2203
2204
2205 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2206 #define SWIG_From_long PyInt_FromLong
2207 /*@@*/
2208
2209 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2210 // We use only strings for the streams, not unicode
2211 PyObject* str = PyObject_Str(obj);
2212 if (! str) {
2213 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2214 return;
2215 }
2216 self->Write(PyString_AS_STRING(str),
2217 PyString_GET_SIZE(str));
2218 Py_DECREF(str);
2219 }
2220
2221 #include "wx/wxPython/pyistream.h"
2222
2223
2224 class wxPyFileSystemHandler : public wxFileSystemHandler
2225 {
2226 public:
2227 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2228
2229 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2230 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2231 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2232 DEC_PYCALLBACK_STRING__pure(FindNext);
2233
2234 wxString GetProtocol(const wxString& location) {
2235 return wxFileSystemHandler::GetProtocol(location);
2236 }
2237
2238 wxString GetLeftLocation(const wxString& location) {
2239 return wxFileSystemHandler::GetLeftLocation(location);
2240 }
2241
2242 wxString GetAnchor(const wxString& location) {
2243 return wxFileSystemHandler::GetAnchor(location);
2244 }
2245
2246 wxString GetRightLocation(const wxString& location) {
2247 return wxFileSystemHandler::GetRightLocation(location);
2248 }
2249
2250 wxString GetMimeTypeFromExt(const wxString& location) {
2251 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2252 }
2253
2254 PYPRIVATE;
2255 };
2256
2257
2258 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2259 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2260 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2261 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2262
2263
2264 SWIGINTERN int
2265 SWIG_AsVal_bool(PyObject *obj, bool *val)
2266 {
2267 if (obj == Py_True) {
2268 if (val) *val = true;
2269 return 1;
2270 }
2271 if (obj == Py_False) {
2272 if (val) *val = false;
2273 return 1;
2274 }
2275 int res = 0;
2276 if (SWIG_AsVal_int(obj, &res)) {
2277 if (val) *val = res ? true : false;
2278 return 1;
2279 } else {
2280 PyErr_Clear();
2281 }
2282 if (val) {
2283 SWIG_type_error("bool", obj);
2284 }
2285 return 0;
2286 }
2287
2288
2289 SWIGINTERNINLINE bool
2290 SWIG_As_bool(PyObject* obj)
2291 {
2292 bool v;
2293 if (!SWIG_AsVal_bool(obj, &v)) {
2294 /*
2295 this is needed to make valgrind/purify happier.
2296 */
2297 memset((void*)&v, 0, sizeof(bool));
2298 }
2299 return v;
2300 }
2301
2302
2303 SWIGINTERNINLINE int
2304 SWIG_Check_bool(PyObject* obj)
2305 {
2306 return SWIG_AsVal_bool(obj, (bool*)0);
2307 }
2308
2309 static wxString wxFileSystem_URLToFileName(wxString const &url){
2310 wxFileName fname = wxFileSystem::URLToFileName(url);
2311 return fname.GetFullPath();
2312 }
2313
2314 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2315 wxImage& image,
2316 long type) {
2317 wxMemoryFSHandler::AddFile(filename, image, type);
2318 }
2319
2320 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2321 const wxBitmap& bitmap,
2322 long type) {
2323 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2324 }
2325
2326 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2327 PyObject* data) {
2328 if (! PyString_Check(data)) {
2329 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2330 "Expected string object"));
2331 return;
2332 }
2333
2334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2335 void* ptr = (void*)PyString_AsString(data);
2336 size_t size = PyString_Size(data);
2337 wxPyEndBlockThreads(blocked);
2338
2339 wxMemoryFSHandler::AddFile(filename, ptr, size);
2340 }
2341
2342
2343 #include "wx/wxPython/pyistream.h"
2344
2345
2346 SWIGINTERN int
2347 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2348 {
2349 long v = 0;
2350 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2351 SWIG_Python_TypeError("unsigned number", obj);
2352 }
2353 else if (val)
2354 *val = (unsigned long)v;
2355 return 1;
2356 }
2357
2358
2359 SWIGINTERNINLINE int
2360 SWIG_CheckUnsignedLongInRange(unsigned long value,
2361 unsigned long max_value,
2362 const char *errmsg)
2363 {
2364 if (value > max_value) {
2365 if (errmsg) {
2366 PyErr_Format(PyExc_OverflowError,
2367 "value %lu is greater than '%s' minimum %lu",
2368 value, errmsg, max_value);
2369 }
2370 return 0;
2371 }
2372 return 1;
2373 }
2374
2375
2376 SWIGINTERN int
2377 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2378 {
2379 const char* errmsg = val ? "unsigned char" : (char*)0;
2380 unsigned long v;
2381 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2382 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2383 if (val) *val = static_cast<unsigned char >(v);
2384 return 1;
2385 } else {
2386 return 0;
2387 }
2388 } else {
2389 PyErr_Clear();
2390 }
2391 if (val) {
2392 SWIG_type_error(errmsg, obj);
2393 }
2394 return 0;
2395 }
2396
2397
2398 SWIGINTERNINLINE unsigned char
2399 SWIG_As_unsigned_SS_char(PyObject* obj)
2400 {
2401 unsigned char v;
2402 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2403 /*
2404 this is needed to make valgrind/purify happier.
2405 */
2406 memset((void*)&v, 0, sizeof(unsigned char));
2407 }
2408 return v;
2409 }
2410
2411
2412 SWIGINTERNINLINE int
2413 SWIG_Check_unsigned_SS_char(PyObject* obj)
2414 {
2415 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2416 }
2417
2418
2419 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2420 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2421 /*@@*/
2422
2423
2424
2425 SWIGINTERNINLINE unsigned long
2426 SWIG_As_unsigned_SS_long(PyObject* obj)
2427 {
2428 unsigned long v;
2429 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2430 /*
2431 this is needed to make valgrind/purify happier.
2432 */
2433 memset((void*)&v, 0, sizeof(unsigned long));
2434 }
2435 return v;
2436 }
2437
2438
2439 SWIGINTERNINLINE int
2440 SWIG_Check_unsigned_SS_long(PyObject* obj)
2441 {
2442 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2443 }
2444
2445 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2446 wxImageHistogramEntry e = (*self)[key];
2447 return e.value;
2448 }
2449 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2450 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2451 wxImageHistogramEntry e = (*self)[key];
2452 return e.value;
2453 }
2454 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2455 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2456 colour.Green(),
2457 colour.Blue());
2458 wxImageHistogramEntry e = (*self)[key];
2459 return e.value;
2460 }
2461
2462 typedef unsigned char* buffer;
2463
2464
2465 // Pull the nested class out to the top level for SWIG's sake
2466 #define wxImage_RGBValue wxImage::RGBValue
2467 #define wxImage_HSVValue wxImage::HSVValue
2468
2469 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2470 if (width > 0 && height > 0)
2471 return new wxImage(width, height, clear);
2472 else
2473 return new wxImage;
2474 }
2475 static wxImage *new_wxImage(wxBitmap const &bitmap){
2476 return new wxImage(bitmap.ConvertToImage());
2477 }
2478 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2479 if (DATASIZE != width*height*3) {
2480 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2481 return NULL;
2482 }
2483
2484 // Copy the source data so the wxImage can clean it up later
2485 buffer copy = (buffer)malloc(DATASIZE);
2486 if (copy == NULL) {
2487 wxPyBLOCK_THREADS(PyErr_NoMemory());
2488 return NULL;
2489 }
2490 memcpy(copy, data, DATASIZE);
2491 return new wxImage(width, height, copy, false);
2492 }
2493 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2494 if (DATASIZE != width*height*3) {
2495 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2496 return NULL;
2497 }
2498 if (ALPHASIZE != width*height) {
2499 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2500 return NULL;
2501 }
2502
2503 // Copy the source data so the wxImage can clean it up later
2504 buffer dcopy = (buffer)malloc(DATASIZE);
2505 if (dcopy == NULL) {
2506 wxPyBLOCK_THREADS(PyErr_NoMemory());
2507 return NULL;
2508 }
2509 memcpy(dcopy, data, DATASIZE);
2510
2511 buffer acopy = (buffer)malloc(ALPHASIZE);
2512 if (acopy == NULL) {
2513 wxPyBLOCK_THREADS(PyErr_NoMemory());
2514 return NULL;
2515 }
2516 memcpy(acopy, alpha, ALPHASIZE);
2517
2518 return new wxImage(width, height, dcopy, acopy, false);
2519 }
2520 static wxSize wxImage_GetSize(wxImage *self){
2521 wxSize size(self->GetWidth(), self->GetHeight());
2522 return size;
2523 }
2524 static PyObject *wxImage_GetData(wxImage *self){
2525 buffer data = self->GetData();
2526 int len = self->GetWidth() * self->GetHeight() * 3;
2527 PyObject* rv;
2528 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2529 return rv;
2530 }
2531 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2532 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2533 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2534 return;
2535 }
2536 buffer copy = (buffer)malloc(DATASIZE);
2537 if (copy == NULL) {
2538 wxPyBLOCK_THREADS(PyErr_NoMemory());
2539 return;
2540 }
2541 memcpy(copy, data, DATASIZE);
2542 self->SetData(copy, false);
2543 // wxImage takes ownership of copy...
2544 }
2545 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2546 buffer data = self->GetData();
2547 int len = self->GetWidth() * self->GetHeight() * 3;
2548 PyObject* rv;
2549 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2550 return rv;
2551 }
2552 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2555 return;
2556 }
2557 self->SetData(data, true);
2558 }
2559 static PyObject *wxImage_GetAlphaData(wxImage *self){
2560 buffer data = self->GetAlpha();
2561 if (! data) {
2562 RETURN_NONE();
2563 } else {
2564 int len = self->GetWidth() * self->GetHeight();
2565 PyObject* rv;
2566 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2567 return rv;
2568 }
2569 }
2570 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2571 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2572 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2573 return;
2574 }
2575 buffer acopy = (buffer)malloc(ALPHASIZE);
2576 if (acopy == NULL) {
2577 wxPyBLOCK_THREADS(PyErr_NoMemory());
2578 return;
2579 }
2580 memcpy(acopy, alpha, ALPHASIZE);
2581 self->SetAlpha(acopy, false);
2582 // wxImage takes ownership of acopy...
2583 }
2584 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2585 buffer data = self->GetAlpha();
2586 int len = self->GetWidth() * self->GetHeight();
2587 PyObject* rv;
2588 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2589 return rv;
2590 }
2591 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2594 return;
2595 }
2596 self->SetAlpha(alpha, true);
2597 }
2598 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2599 wxBitmap bitmap(*self, depth);
2600 return bitmap;
2601 }
2602 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2603 wxImage mono = self->ConvertToMono( red, green, blue );
2604 wxBitmap bitmap( mono, 1 );
2605 return bitmap;
2606 }
2607 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2608 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2609 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2610 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2611 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2612 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2613 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2614 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2615 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2616 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2617 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2618 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2619 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2620 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2621 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2622
2623 #include <wx/quantize.h>
2624
2625 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2626 return wxQuantize::Quantize(src, dest,
2627 //NULL, // palette
2628 desiredNoColours,
2629 NULL, // eightBitData
2630 flags);
2631 }
2632 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2633 if (PyCallable_Check(func)) {
2634 self->Connect(id, lastId, eventType,
2635 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2636 new wxPyCallback(func));
2637 }
2638 else if (func == Py_None) {
2639 self->Disconnect(id, lastId, eventType,
2640 (wxObjectEventFunction)
2641 &wxPyCallback::EventThunker);
2642 }
2643 else {
2644 wxPyBLOCK_THREADS(
2645 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2646 }
2647 }
2648 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2649 return self->Disconnect(id, lastId, eventType,
2650 (wxObjectEventFunction)
2651 &wxPyCallback::EventThunker);
2652 }
2653 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2654 if (_self && _self != Py_None) {
2655 self->SetClientObject(new wxPyOORClientData(_self, incref));
2656 }
2657 else {
2658 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2659 if (data) {
2660 self->SetClientObject(NULL); // This will delete it too
2661 }
2662 }
2663 }
2664
2665 #if ! wxUSE_HOTKEY
2666 #define wxEVT_HOTKEY -9999
2667 #endif
2668
2669
2670 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2671 #if wxUSE_UNICODE
2672 return self->GetUnicodeKey();
2673 #else
2674 return 0;
2675 #endif
2676 }
2677
2678 #if UINT_MAX < LONG_MAX
2679 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2680 #define SWIG_From_unsigned_SS_int SWIG_From_long
2681 /*@@*/
2682 #else
2683 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2684 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2685 /*@@*/
2686 #endif
2687
2688
2689 #if UINT_MAX != ULONG_MAX
2690 SWIGINTERN int
2691 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2692 {
2693 const char* errmsg = val ? "unsigned int" : (char*)0;
2694 unsigned long v;
2695 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2696 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2697 if (val) *val = static_cast<unsigned int >(v);
2698 return 1;
2699 }
2700 } else {
2701 PyErr_Clear();
2702 }
2703 if (val) {
2704 SWIG_type_error(errmsg, obj);
2705 }
2706 return 0;
2707 }
2708 #else
2709 SWIGINTERNINLINE unsigned int
2710 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2711 {
2712 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2713 }
2714 #endif
2715
2716
2717 SWIGINTERNINLINE unsigned int
2718 SWIG_As_unsigned_SS_int(PyObject* obj)
2719 {
2720 unsigned int v;
2721 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2722 /*
2723 this is needed to make valgrind/purify happier.
2724 */
2725 memset((void*)&v, 0, sizeof(unsigned int));
2726 }
2727 return v;
2728 }
2729
2730
2731 SWIGINTERNINLINE int
2732 SWIG_Check_unsigned_SS_int(PyObject* obj)
2733 {
2734 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2735 }
2736
2737 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2738 self->m_size = size;
2739 }
2740 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2741 int count = self->GetNumberOfFiles();
2742 wxString* files = self->GetFiles();
2743 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2744 PyObject* list = PyList_New(count);
2745
2746 if (!list) {
2747 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2748 wxPyEndBlockThreads(blocked);
2749 return NULL;
2750 }
2751
2752 for (int i=0; i<count; i++) {
2753 PyList_SetItem(list, i, wx2PyString(files[i]));
2754 }
2755 wxPyEndBlockThreads(blocked);
2756 return list;
2757 }
2758
2759
2760 static wxPyApp *new_wxPyApp(){
2761 wxPythonApp = new wxPyApp();
2762 return wxPythonApp;
2763 }
2764
2765 void wxApp_CleanUp() {
2766 __wxPyCleanup();
2767 }
2768
2769
2770 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2771
2772
2773 SWIGINTERNINLINE int
2774 SWIG_AsCharPtr(PyObject *obj, char **val)
2775 {
2776 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2777 return 1;
2778 }
2779 if (val) {
2780 PyErr_Clear();
2781 SWIG_type_error("char *", obj);
2782 }
2783 return 0;
2784 }
2785
2786
2787 SWIGINTERN PyObject *
2788 SWIG_FromCharPtr(const char* cptr)
2789 {
2790 if (cptr) {
2791 size_t size = strlen(cptr);
2792 if (size > INT_MAX) {
2793 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2794 SWIG_TypeQuery("char *"), 0);
2795 } else {
2796 if (size != 0) {
2797 return PyString_FromStringAndSize(cptr, size);
2798 } else {
2799 return PyString_FromString(cptr);
2800 }
2801 }
2802 }
2803 Py_INCREF(Py_None);
2804 return Py_None;
2805 }
2806
2807
2808 #if 0 // #ifdef __WXMAC__
2809
2810 // A dummy class that raises an exception if used...
2811 class wxEventLoop
2812 {
2813 public:
2814 wxEventLoop() { wxPyRaiseNotImplemented(); }
2815 int Run() { return 0; }
2816 void Exit(int rc = 0) {}
2817 bool Pending() const { return false; }
2818 bool Dispatch() { return false; }
2819 bool IsRunning() const { return false; }
2820 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2821 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2822 };
2823
2824 #else
2825
2826 #include <wx/evtloop.h>
2827
2828 #endif
2829
2830
2831
2832 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2833 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2834 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2835 static PyObject *wxWindow_GetChildren(wxWindow *self){
2836 wxWindowList& list = self->GetChildren();
2837 return wxPy_ConvertList(&list);
2838 }
2839 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2840 #if wxUSE_HOTKEY
2841 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2842 #else
2843 return false;
2844 #endif
2845 }
2846 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2847
2848
2849
2850 return false;
2851
2852 }
2853 static long wxWindow_GetHandle(wxWindow *self){
2854 return wxPyGetWinHandle(self);
2855 }
2856 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2857 self->AssociateHandle((WXWidget)handle);
2858 }
2859
2860 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2861 return wxWindow::FindWindowById(id, parent);
2862 }
2863
2864 wxWindow* wxFindWindowByName( const wxString& name,
2865 const wxWindow *parent = NULL ) {
2866 return wxWindow::FindWindowByName(name, parent);
2867 }
2868
2869 wxWindow* wxFindWindowByLabel( const wxString& label,
2870 const wxWindow *parent = NULL ) {
2871 return wxWindow::FindWindowByLabel(label, parent);
2872 }
2873
2874
2875 #ifdef __WXMSW__
2876 #include <wx/msw/private.h> // to get wxGetWindowId
2877 #endif
2878
2879
2880 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2881 #ifdef __WXMSW__
2882 WXHWND hWnd = (WXHWND)_hWnd;
2883 long id = wxGetWindowId(hWnd);
2884 wxWindow* win = new wxWindow;
2885 if (parent)
2886 parent->AddChild(win);
2887 win->SetEventHandler(win);
2888 win->SetHWND(hWnd);
2889 win->SetId(id);
2890 win->SubclassWin(hWnd);
2891 win->AdoptAttributesFromHWND();
2892 win->SetupColours();
2893 return win;
2894 #else
2895 wxPyRaiseNotImplemented();
2896 return NULL;
2897 #endif
2898 }
2899
2900
2901 PyObject* GetTopLevelWindows() {
2902 return wxPy_ConvertList(&wxTopLevelWindows);
2903 }
2904
2905
2906 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2907 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2908 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2909
2910 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2911
2912 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2913 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2914 wxMenuItemList& list = self->GetMenuItems();
2915 return wxPy_ConvertList(&list);
2916 }
2917 static void wxMenuBar_SetAutoWindowMenu(bool enable){}
2918 static bool wxMenuBar_GetAutoWindowMenu(){ return false; }
2919 static const wxString wxPyControlNameStr(wxControlNameStr);
2920 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2921 if (clientData) {
2922 wxPyClientData* data = new wxPyClientData(clientData);
2923 return self->Append(item, data);
2924 } else
2925 return self->Append(item);
2926 }
2927 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2928 if (clientData) {
2929 wxPyClientData* data = new wxPyClientData(clientData);
2930 return self->Insert(item, pos, data);
2931 } else
2932 return self->Insert(item, pos);
2933 }
2934 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2935 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2936 if (data) {
2937 Py_INCREF(data->m_obj);
2938 return data->m_obj;
2939 } else {
2940 Py_INCREF(Py_None);
2941 return Py_None;
2942 }
2943 }
2944 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2945 wxPyClientData* data = new wxPyClientData(clientData);
2946 self->SetClientObject(n, data);
2947 }
2948
2949
2950 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2951 wxPyUserData* data = NULL;
2952 if ( userData ) {
2953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2954 data = new wxPyUserData(userData);
2955 wxPyEndBlockThreads(blocked);
2956 }
2957 return new wxSizerItem(window, proportion, flag, border, data);
2958 }
2959 static wxSizerItem *new_wxSizerItem(int width,int height,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(width, height, proportion, flag, border, data);
2967 }
2968 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,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(sizer, proportion, flag, border, data);
2976 }
2977
2978 #include <float.h>
2979 SWIGINTERN int
2980 SWIG_CheckDoubleInRange(double value, double min_value,
2981 double max_value, const char* errmsg)
2982 {
2983 if (value < min_value) {
2984 if (errmsg) {
2985 PyErr_Format(PyExc_OverflowError,
2986 "value %g is less than %s minimum %g",
2987 value, errmsg, min_value);
2988 }
2989 return 0;
2990 } else if (value > max_value) {
2991 if (errmsg) {
2992 PyErr_Format(PyExc_OverflowError,
2993 "value %g is greater than %s maximum %g",
2994 value, errmsg, max_value);
2995 }
2996 return 0;
2997 }
2998 return 1;
2999 }
3000
3001
3002 SWIGINTERN int
3003 SWIG_AsVal_float(PyObject *obj, float *val)
3004 {
3005 const char* errmsg = val ? "float" : (char*)0;
3006 double v;
3007 if (SWIG_AsVal_double(obj, &v)) {
3008 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3009 if (val) *val = static_cast<float >(v);
3010 return 1;
3011 } else {
3012 return 0;
3013 }
3014 } else {
3015 PyErr_Clear();
3016 }
3017 if (val) {
3018 SWIG_type_error(errmsg, obj);
3019 }
3020 return 0;
3021 }
3022
3023
3024 SWIGINTERNINLINE float
3025 SWIG_As_float(PyObject* obj)
3026 {
3027 float v;
3028 if (!SWIG_AsVal_float(obj, &v)) {
3029 /*
3030 this is needed to make valgrind/purify happier.
3031 */
3032 memset((void*)&v, 0, sizeof(float));
3033 }
3034 return v;
3035 }
3036
3037
3038 SWIGINTERNINLINE int
3039 SWIG_Check_float(PyObject* obj)
3040 {
3041 return SWIG_AsVal_float(obj, (float*)0);
3042 }
3043
3044
3045 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
3046 #define SWIG_From_float PyFloat_FromDouble
3047 /*@@*/
3048
3049 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3050 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3051 if (data) {
3052 Py_INCREF(data->m_obj);
3053 return data->m_obj;
3054 } else {
3055 Py_INCREF(Py_None);
3056 return Py_None;
3057 }
3058 }
3059 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3060 wxPyUserData* data = NULL;
3061 if ( userData ) {
3062 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3063 data = new wxPyUserData(userData);
3064 wxPyEndBlockThreads(blocked);
3065 }
3066 self->SetUserData(data);
3067 }
3068
3069 // Figure out the type of the sizer item
3070
3071 struct wxPySizerItemInfo {
3072 wxPySizerItemInfo()
3073 : window(NULL), sizer(NULL), gotSize(false),
3074 size(wxDefaultSize), gotPos(false), pos(-1)
3075 {}
3076
3077 wxWindow* window;
3078 wxSizer* sizer;
3079 bool gotSize;
3080 wxSize size;
3081 bool gotPos;
3082 int pos;
3083 };
3084
3085 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3086
3087 wxPySizerItemInfo info;
3088 wxSize size;
3089 wxSize* sizePtr = &size;
3090
3091 // Find out what the type of the item is
3092 // try wxWindow
3093 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3094 PyErr_Clear();
3095 info.window = NULL;
3096
3097 // try wxSizer
3098 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3099 PyErr_Clear();
3100 info.sizer = NULL;
3101
3102 // try wxSize or (w,h)
3103 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3104 info.size = *sizePtr;
3105 info.gotSize = true;
3106 }
3107
3108 // or a single int
3109 if (checkIdx && PyInt_Check(item)) {
3110 info.pos = PyInt_AsLong(item);
3111 info.gotPos = true;
3112 }
3113 }
3114 }
3115
3116 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3117 // no expected type, figure out what kind of error message to generate
3118 if ( !checkSize && !checkIdx )
3119 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3120 else if ( checkSize && !checkIdx )
3121 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3122 else if ( !checkSize && checkIdx)
3123 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3124 else
3125 // can this one happen?
3126 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3127 }
3128
3129 return info;
3130 }
3131
3132 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3133 if (!self->GetClientObject())
3134 self->SetClientObject(new wxPyOORClientData(_self));
3135 }
3136 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3137
3138 wxPyUserData* data = NULL;
3139 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3140 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3141 if ( userData && (info.window || info.sizer || info.gotSize) )
3142 data = new wxPyUserData(userData);
3143 if ( info.sizer )
3144 PyObject_SetAttrString(item,"thisown",Py_False);
3145 wxPyEndBlockThreads(blocked);
3146
3147 // Now call the real Add method if a valid item type was found
3148 if ( info.window )
3149 return self->Add(info.window, proportion, flag, border, data);
3150 else if ( info.sizer )
3151 return self->Add(info.sizer, proportion, flag, border, data);
3152 else if (info.gotSize)
3153 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3154 proportion, flag, border, data);
3155 else
3156 return NULL;
3157 }
3158 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3159
3160 wxPyUserData* data = NULL;
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3163 if ( userData && (info.window || info.sizer || info.gotSize) )
3164 data = new wxPyUserData(userData);
3165 if ( info.sizer )
3166 PyObject_SetAttrString(item,"thisown",Py_False);
3167 wxPyEndBlockThreads(blocked);
3168
3169 // Now call the real Insert method if a valid item type was found
3170 if ( info.window )
3171 return self->Insert(before, info.window, proportion, flag, border, data);
3172 else if ( info.sizer )
3173 return self->Insert(before, info.sizer, proportion, flag, border, data);
3174 else if (info.gotSize)
3175 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3176 proportion, flag, border, data);
3177 else
3178 return NULL;
3179 }
3180 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3181
3182 wxPyUserData* data = NULL;
3183 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3184 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3185 if ( userData && (info.window || info.sizer || info.gotSize) )
3186 data = new wxPyUserData(userData);
3187 if ( info.sizer )
3188 PyObject_SetAttrString(item,"thisown",Py_False);
3189 wxPyEndBlockThreads(blocked);
3190
3191 // Now call the real Prepend method if a valid item type was found
3192 if ( info.window )
3193 return self->Prepend(info.window, proportion, flag, border, data);
3194 else if ( info.sizer )
3195 return self->Prepend(info.sizer, proportion, flag, border, data);
3196 else if (info.gotSize)
3197 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3198 proportion, flag, border, data);
3199 else
3200 return NULL;
3201 }
3202 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3204 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3205 wxPyEndBlockThreads(blocked);
3206 if ( info.window )
3207 return self->Remove(info.window);
3208 else if ( info.sizer )
3209 return self->Remove(info.sizer);
3210 else if ( info.gotPos )
3211 return self->Remove(info.pos);
3212 else
3213 return false;
3214 }
3215 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3218 wxPyEndBlockThreads(blocked);
3219 if ( info.window )
3220 return self->Detach(info.window);
3221 else if ( info.sizer )
3222 return self->Detach(info.sizer);
3223 else if ( info.gotPos )
3224 return self->Detach(info.pos);
3225 else
3226 return false;
3227 }
3228 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3229 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3230 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3231 wxPyEndBlockThreads(blocked);
3232 if ( info.window )
3233 return self->GetItem(info.window);
3234 else if ( info.sizer )
3235 return self->GetItem(info.sizer);
3236 else if ( info.gotPos )
3237 return self->GetItem(info.pos);
3238 else
3239 return NULL;
3240 }
3241 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3242 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3243 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3244 wxPyEndBlockThreads(blocked);
3245 if ( info.window )
3246 self->SetItemMinSize(info.window, size);
3247 else if ( info.sizer )
3248 self->SetItemMinSize(info.sizer, size);
3249 else if ( info.gotPos )
3250 self->SetItemMinSize(info.pos, size);
3251 }
3252 static PyObject *wxSizer_GetChildren(wxSizer *self){
3253 wxSizerItemList& list = self->GetChildren();
3254 return wxPy_ConvertList(&list);
3255 }
3256 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3257 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3258 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3259 wxPyEndBlockThreads(blocked);
3260 if ( info.window )
3261 return self->Show(info.window, show, recursive);
3262 else if ( info.sizer )
3263 return self->Show(info.sizer, show, recursive);
3264 else if ( info.gotPos )
3265 return self->Show(info.pos, show);
3266 else
3267 return false;
3268 }
3269 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3270 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3271 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3272 wxPyEndBlockThreads(blocked);
3273 if ( info.window )
3274 return self->IsShown(info.window);
3275 else if ( info.sizer )
3276 return self->IsShown(info.sizer);
3277 else if ( info.gotPos )
3278 return self->IsShown(info.pos);
3279 else
3280 return false;
3281 }
3282
3283 // See pyclasses.h
3284 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3285 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3286 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3287
3288
3289
3290
3291 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3292 {
3293 if (source == Py_None) {
3294 **obj = wxGBPosition(-1,-1);
3295 return true;
3296 }
3297 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3298 }
3299
3300 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3301 {
3302 if (source == Py_None) {
3303 **obj = wxGBSpan(-1,-1);
3304 return true;
3305 }
3306 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3307 }
3308
3309
3310 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3311 self->SetRow(row);
3312 self->SetCol(col);
3313 }
3314 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3315 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3316 PyObject* tup = PyTuple_New(2);
3317 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3318 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3319 wxPyEndBlockThreads(blocked);
3320 return tup;
3321 }
3322 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3323 self->SetRowspan(rowspan);
3324 self->SetColspan(colspan);
3325 }
3326 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3328 PyObject* tup = PyTuple_New(2);
3329 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3330 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3331 wxPyEndBlockThreads(blocked);
3332 return tup;
3333 }
3334 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3335 wxPyUserData* data = NULL;
3336 if ( userData ) {
3337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3338 data = new wxPyUserData(userData);
3339 wxPyEndBlockThreads(blocked);
3340 }
3341 return new wxGBSizerItem(window, pos, span, flag, border, data);
3342 }
3343 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,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(sizer, pos, span, flag, border, data);
3351 }
3352 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,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(width, height, pos, span, flag, border, data);
3360 }
3361 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3362 int row, col;
3363 self->GetEndPos(row, col);
3364 return wxGBPosition(row, col);
3365 }
3366 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3367
3368 wxPyUserData* data = NULL;
3369 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3370 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3371 if ( userData && (info.window || info.sizer || info.gotSize) )
3372 data = new wxPyUserData(userData);
3373 if ( info.sizer )
3374 PyObject_SetAttrString(item,"thisown",Py_False);
3375 wxPyEndBlockThreads(blocked);
3376
3377 // Now call the real Add method if a valid item type was found
3378 if ( info.window )
3379 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3380 else if ( info.sizer )
3381 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3382 else if (info.gotSize)
3383 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3384 pos, span, flag, border, data);
3385 return NULL;
3386 }
3387
3388
3389 #ifdef __cplusplus
3390 extern "C" {
3391 #endif
3392 static int _wrap_EmptyString_set(PyObject *) {
3393 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3394 return 1;
3395 }
3396
3397
3398 static PyObject *_wrap_EmptyString_get(void) {
3399 PyObject *pyobj = NULL;
3400
3401 {
3402 #if wxUSE_UNICODE
3403 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3404 #else
3405 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3406 #endif
3407 }
3408 return pyobj;
3409 }
3410
3411
3412 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3413 PyObject *resultobj = NULL;
3414 wxObject *arg1 = (wxObject *) 0 ;
3415 wxString result;
3416 PyObject * obj0 = 0 ;
3417 char *kwnames[] = {
3418 (char *) "self", NULL
3419 };
3420
3421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3423 if (SWIG_arg_fail(1)) SWIG_fail;
3424 {
3425 PyThreadState* __tstate = wxPyBeginAllowThreads();
3426 result = wxObject_GetClassName(arg1);
3427
3428 wxPyEndAllowThreads(__tstate);
3429 if (PyErr_Occurred()) SWIG_fail;
3430 }
3431 {
3432 #if wxUSE_UNICODE
3433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3434 #else
3435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3436 #endif
3437 }
3438 return resultobj;
3439 fail:
3440 return NULL;
3441 }
3442
3443
3444 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3445 PyObject *resultobj = NULL;
3446 wxObject *arg1 = (wxObject *) 0 ;
3447 PyObject * obj0 = 0 ;
3448 char *kwnames[] = {
3449 (char *) "self", NULL
3450 };
3451
3452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3454 if (SWIG_arg_fail(1)) SWIG_fail;
3455 {
3456 PyThreadState* __tstate = wxPyBeginAllowThreads();
3457 wxObject_Destroy(arg1);
3458
3459 wxPyEndAllowThreads(__tstate);
3460 if (PyErr_Occurred()) SWIG_fail;
3461 }
3462 Py_INCREF(Py_None); resultobj = Py_None;
3463 return resultobj;
3464 fail:
3465 return NULL;
3466 }
3467
3468
3469 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3470 PyObject *obj;
3471 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3472 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3473 Py_INCREF(obj);
3474 return Py_BuildValue((char *)"");
3475 }
3476 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3477 PyObject *resultobj = NULL;
3478 wxSize *arg1 = (wxSize *) 0 ;
3479 int arg2 ;
3480 PyObject * obj0 = 0 ;
3481 PyObject * obj1 = 0 ;
3482 char *kwnames[] = {
3483 (char *) "self",(char *) "x", NULL
3484 };
3485
3486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3488 if (SWIG_arg_fail(1)) SWIG_fail;
3489 {
3490 arg2 = static_cast<int >(SWIG_As_int(obj1));
3491 if (SWIG_arg_fail(2)) SWIG_fail;
3492 }
3493 if (arg1) (arg1)->x = arg2;
3494
3495 Py_INCREF(Py_None); resultobj = Py_None;
3496 return resultobj;
3497 fail:
3498 return NULL;
3499 }
3500
3501
3502 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3503 PyObject *resultobj = NULL;
3504 wxSize *arg1 = (wxSize *) 0 ;
3505 int result;
3506 PyObject * obj0 = 0 ;
3507 char *kwnames[] = {
3508 (char *) "self", NULL
3509 };
3510
3511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3513 if (SWIG_arg_fail(1)) SWIG_fail;
3514 result = (int) ((arg1)->x);
3515
3516 {
3517 resultobj = SWIG_From_int(static_cast<int >(result));
3518 }
3519 return resultobj;
3520 fail:
3521 return NULL;
3522 }
3523
3524
3525 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3526 PyObject *resultobj = NULL;
3527 wxSize *arg1 = (wxSize *) 0 ;
3528 int arg2 ;
3529 PyObject * obj0 = 0 ;
3530 PyObject * obj1 = 0 ;
3531 char *kwnames[] = {
3532 (char *) "self",(char *) "y", NULL
3533 };
3534
3535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3537 if (SWIG_arg_fail(1)) SWIG_fail;
3538 {
3539 arg2 = static_cast<int >(SWIG_As_int(obj1));
3540 if (SWIG_arg_fail(2)) SWIG_fail;
3541 }
3542 if (arg1) (arg1)->y = arg2;
3543
3544 Py_INCREF(Py_None); resultobj = Py_None;
3545 return resultobj;
3546 fail:
3547 return NULL;
3548 }
3549
3550
3551 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3552 PyObject *resultobj = NULL;
3553 wxSize *arg1 = (wxSize *) 0 ;
3554 int result;
3555 PyObject * obj0 = 0 ;
3556 char *kwnames[] = {
3557 (char *) "self", NULL
3558 };
3559
3560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3562 if (SWIG_arg_fail(1)) SWIG_fail;
3563 result = (int) ((arg1)->y);
3564
3565 {
3566 resultobj = SWIG_From_int(static_cast<int >(result));
3567 }
3568 return resultobj;
3569 fail:
3570 return NULL;
3571 }
3572
3573
3574 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3575 PyObject *resultobj = NULL;
3576 int arg1 = (int) 0 ;
3577 int arg2 = (int) 0 ;
3578 wxSize *result;
3579 PyObject * obj0 = 0 ;
3580 PyObject * obj1 = 0 ;
3581 char *kwnames[] = {
3582 (char *) "w",(char *) "h", NULL
3583 };
3584
3585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3586 if (obj0) {
3587 {
3588 arg1 = static_cast<int >(SWIG_As_int(obj0));
3589 if (SWIG_arg_fail(1)) SWIG_fail;
3590 }
3591 }
3592 if (obj1) {
3593 {
3594 arg2 = static_cast<int >(SWIG_As_int(obj1));
3595 if (SWIG_arg_fail(2)) SWIG_fail;
3596 }
3597 }
3598 {
3599 PyThreadState* __tstate = wxPyBeginAllowThreads();
3600 result = (wxSize *)new wxSize(arg1,arg2);
3601
3602 wxPyEndAllowThreads(__tstate);
3603 if (PyErr_Occurred()) SWIG_fail;
3604 }
3605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3606 return resultobj;
3607 fail:
3608 return NULL;
3609 }
3610
3611
3612 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3613 PyObject *resultobj = NULL;
3614 wxSize *arg1 = (wxSize *) 0 ;
3615 PyObject * obj0 = 0 ;
3616 char *kwnames[] = {
3617 (char *) "self", NULL
3618 };
3619
3620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3622 if (SWIG_arg_fail(1)) SWIG_fail;
3623 {
3624 PyThreadState* __tstate = wxPyBeginAllowThreads();
3625 delete arg1;
3626
3627 wxPyEndAllowThreads(__tstate);
3628 if (PyErr_Occurred()) SWIG_fail;
3629 }
3630 Py_INCREF(Py_None); resultobj = Py_None;
3631 return resultobj;
3632 fail:
3633 return NULL;
3634 }
3635
3636
3637 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3638 PyObject *resultobj = NULL;
3639 wxSize *arg1 = (wxSize *) 0 ;
3640 wxSize *arg2 = 0 ;
3641 bool result;
3642 wxSize temp2 ;
3643 PyObject * obj0 = 0 ;
3644 PyObject * obj1 = 0 ;
3645 char *kwnames[] = {
3646 (char *) "self",(char *) "sz", NULL
3647 };
3648
3649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3651 if (SWIG_arg_fail(1)) SWIG_fail;
3652 {
3653 arg2 = &temp2;
3654 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3655 }
3656 {
3657 PyThreadState* __tstate = wxPyBeginAllowThreads();
3658 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3659
3660 wxPyEndAllowThreads(__tstate);
3661 if (PyErr_Occurred()) SWIG_fail;
3662 }
3663 {
3664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3665 }
3666 return resultobj;
3667 fail:
3668 return NULL;
3669 }
3670
3671
3672 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3673 PyObject *resultobj = NULL;
3674 wxSize *arg1 = (wxSize *) 0 ;
3675 wxSize *arg2 = 0 ;
3676 bool result;
3677 wxSize temp2 ;
3678 PyObject * obj0 = 0 ;
3679 PyObject * obj1 = 0 ;
3680 char *kwnames[] = {
3681 (char *) "self",(char *) "sz", NULL
3682 };
3683
3684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3686 if (SWIG_arg_fail(1)) SWIG_fail;
3687 {
3688 arg2 = &temp2;
3689 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3690 }
3691 {
3692 PyThreadState* __tstate = wxPyBeginAllowThreads();
3693 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3694
3695 wxPyEndAllowThreads(__tstate);
3696 if (PyErr_Occurred()) SWIG_fail;
3697 }
3698 {
3699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3700 }
3701 return resultobj;
3702 fail:
3703 return NULL;
3704 }
3705
3706
3707 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3708 PyObject *resultobj = NULL;
3709 wxSize *arg1 = (wxSize *) 0 ;
3710 wxSize *arg2 = 0 ;
3711 wxSize result;
3712 wxSize temp2 ;
3713 PyObject * obj0 = 0 ;
3714 PyObject * obj1 = 0 ;
3715 char *kwnames[] = {
3716 (char *) "self",(char *) "sz", NULL
3717 };
3718
3719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3721 if (SWIG_arg_fail(1)) SWIG_fail;
3722 {
3723 arg2 = &temp2;
3724 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3725 }
3726 {
3727 PyThreadState* __tstate = wxPyBeginAllowThreads();
3728 result = (arg1)->operator +((wxSize const &)*arg2);
3729
3730 wxPyEndAllowThreads(__tstate);
3731 if (PyErr_Occurred()) SWIG_fail;
3732 }
3733 {
3734 wxSize * resultptr;
3735 resultptr = new wxSize(static_cast<wxSize & >(result));
3736 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3737 }
3738 return resultobj;
3739 fail:
3740 return NULL;
3741 }
3742
3743
3744 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3745 PyObject *resultobj = NULL;
3746 wxSize *arg1 = (wxSize *) 0 ;
3747 wxSize *arg2 = 0 ;
3748 wxSize result;
3749 wxSize temp2 ;
3750 PyObject * obj0 = 0 ;
3751 PyObject * obj1 = 0 ;
3752 char *kwnames[] = {
3753 (char *) "self",(char *) "sz", NULL
3754 };
3755
3756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3758 if (SWIG_arg_fail(1)) SWIG_fail;
3759 {
3760 arg2 = &temp2;
3761 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3762 }
3763 {
3764 PyThreadState* __tstate = wxPyBeginAllowThreads();
3765 result = (arg1)->operator -((wxSize const &)*arg2);
3766
3767 wxPyEndAllowThreads(__tstate);
3768 if (PyErr_Occurred()) SWIG_fail;
3769 }
3770 {
3771 wxSize * resultptr;
3772 resultptr = new wxSize(static_cast<wxSize & >(result));
3773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3774 }
3775 return resultobj;
3776 fail:
3777 return NULL;
3778 }
3779
3780
3781 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3782 PyObject *resultobj = NULL;
3783 wxSize *arg1 = (wxSize *) 0 ;
3784 wxSize *arg2 = 0 ;
3785 wxSize temp2 ;
3786 PyObject * obj0 = 0 ;
3787 PyObject * obj1 = 0 ;
3788 char *kwnames[] = {
3789 (char *) "self",(char *) "sz", NULL
3790 };
3791
3792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3794 if (SWIG_arg_fail(1)) SWIG_fail;
3795 {
3796 arg2 = &temp2;
3797 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3798 }
3799 {
3800 PyThreadState* __tstate = wxPyBeginAllowThreads();
3801 (arg1)->IncTo((wxSize const &)*arg2);
3802
3803 wxPyEndAllowThreads(__tstate);
3804 if (PyErr_Occurred()) SWIG_fail;
3805 }
3806 Py_INCREF(Py_None); resultobj = Py_None;
3807 return resultobj;
3808 fail:
3809 return NULL;
3810 }
3811
3812
3813 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3814 PyObject *resultobj = NULL;
3815 wxSize *arg1 = (wxSize *) 0 ;
3816 wxSize *arg2 = 0 ;
3817 wxSize temp2 ;
3818 PyObject * obj0 = 0 ;
3819 PyObject * obj1 = 0 ;
3820 char *kwnames[] = {
3821 (char *) "self",(char *) "sz", NULL
3822 };
3823
3824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3826 if (SWIG_arg_fail(1)) SWIG_fail;
3827 {
3828 arg2 = &temp2;
3829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3830 }
3831 {
3832 PyThreadState* __tstate = wxPyBeginAllowThreads();
3833 (arg1)->DecTo((wxSize const &)*arg2);
3834
3835 wxPyEndAllowThreads(__tstate);
3836 if (PyErr_Occurred()) SWIG_fail;
3837 }
3838 Py_INCREF(Py_None); resultobj = Py_None;
3839 return resultobj;
3840 fail:
3841 return NULL;
3842 }
3843
3844
3845 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3846 PyObject *resultobj = NULL;
3847 wxSize *arg1 = (wxSize *) 0 ;
3848 int arg2 ;
3849 int arg3 ;
3850 PyObject * obj0 = 0 ;
3851 PyObject * obj1 = 0 ;
3852 PyObject * obj2 = 0 ;
3853 char *kwnames[] = {
3854 (char *) "self",(char *) "w",(char *) "h", NULL
3855 };
3856
3857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3859 if (SWIG_arg_fail(1)) SWIG_fail;
3860 {
3861 arg2 = static_cast<int >(SWIG_As_int(obj1));
3862 if (SWIG_arg_fail(2)) SWIG_fail;
3863 }
3864 {
3865 arg3 = static_cast<int >(SWIG_As_int(obj2));
3866 if (SWIG_arg_fail(3)) SWIG_fail;
3867 }
3868 {
3869 PyThreadState* __tstate = wxPyBeginAllowThreads();
3870 (arg1)->Set(arg2,arg3);
3871
3872 wxPyEndAllowThreads(__tstate);
3873 if (PyErr_Occurred()) SWIG_fail;
3874 }
3875 Py_INCREF(Py_None); resultobj = Py_None;
3876 return resultobj;
3877 fail:
3878 return NULL;
3879 }
3880
3881
3882 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3883 PyObject *resultobj = NULL;
3884 wxSize *arg1 = (wxSize *) 0 ;
3885 int arg2 ;
3886 PyObject * obj0 = 0 ;
3887 PyObject * obj1 = 0 ;
3888 char *kwnames[] = {
3889 (char *) "self",(char *) "w", NULL
3890 };
3891
3892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3894 if (SWIG_arg_fail(1)) SWIG_fail;
3895 {
3896 arg2 = static_cast<int >(SWIG_As_int(obj1));
3897 if (SWIG_arg_fail(2)) SWIG_fail;
3898 }
3899 {
3900 PyThreadState* __tstate = wxPyBeginAllowThreads();
3901 (arg1)->SetWidth(arg2);
3902
3903 wxPyEndAllowThreads(__tstate);
3904 if (PyErr_Occurred()) SWIG_fail;
3905 }
3906 Py_INCREF(Py_None); resultobj = Py_None;
3907 return resultobj;
3908 fail:
3909 return NULL;
3910 }
3911
3912
3913 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3914 PyObject *resultobj = NULL;
3915 wxSize *arg1 = (wxSize *) 0 ;
3916 int arg2 ;
3917 PyObject * obj0 = 0 ;
3918 PyObject * obj1 = 0 ;
3919 char *kwnames[] = {
3920 (char *) "self",(char *) "h", NULL
3921 };
3922
3923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3925 if (SWIG_arg_fail(1)) SWIG_fail;
3926 {
3927 arg2 = static_cast<int >(SWIG_As_int(obj1));
3928 if (SWIG_arg_fail(2)) SWIG_fail;
3929 }
3930 {
3931 PyThreadState* __tstate = wxPyBeginAllowThreads();
3932 (arg1)->SetHeight(arg2);
3933
3934 wxPyEndAllowThreads(__tstate);
3935 if (PyErr_Occurred()) SWIG_fail;
3936 }
3937 Py_INCREF(Py_None); resultobj = Py_None;
3938 return resultobj;
3939 fail:
3940 return NULL;
3941 }
3942
3943
3944 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3945 PyObject *resultobj = NULL;
3946 wxSize *arg1 = (wxSize *) 0 ;
3947 int result;
3948 PyObject * obj0 = 0 ;
3949 char *kwnames[] = {
3950 (char *) "self", NULL
3951 };
3952
3953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3955 if (SWIG_arg_fail(1)) SWIG_fail;
3956 {
3957 PyThreadState* __tstate = wxPyBeginAllowThreads();
3958 result = (int)((wxSize const *)arg1)->GetWidth();
3959
3960 wxPyEndAllowThreads(__tstate);
3961 if (PyErr_Occurred()) SWIG_fail;
3962 }
3963 {
3964 resultobj = SWIG_From_int(static_cast<int >(result));
3965 }
3966 return resultobj;
3967 fail:
3968 return NULL;
3969 }
3970
3971
3972 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3973 PyObject *resultobj = NULL;
3974 wxSize *arg1 = (wxSize *) 0 ;
3975 int result;
3976 PyObject * obj0 = 0 ;
3977 char *kwnames[] = {
3978 (char *) "self", NULL
3979 };
3980
3981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3983 if (SWIG_arg_fail(1)) SWIG_fail;
3984 {
3985 PyThreadState* __tstate = wxPyBeginAllowThreads();
3986 result = (int)((wxSize const *)arg1)->GetHeight();
3987
3988 wxPyEndAllowThreads(__tstate);
3989 if (PyErr_Occurred()) SWIG_fail;
3990 }
3991 {
3992 resultobj = SWIG_From_int(static_cast<int >(result));
3993 }
3994 return resultobj;
3995 fail:
3996 return NULL;
3997 }
3998
3999
4000 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
4001 PyObject *resultobj = NULL;
4002 wxSize *arg1 = (wxSize *) 0 ;
4003 bool result;
4004 PyObject * obj0 = 0 ;
4005 char *kwnames[] = {
4006 (char *) "self", NULL
4007 };
4008
4009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
4010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4011 if (SWIG_arg_fail(1)) SWIG_fail;
4012 {
4013 PyThreadState* __tstate = wxPyBeginAllowThreads();
4014 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4015
4016 wxPyEndAllowThreads(__tstate);
4017 if (PyErr_Occurred()) SWIG_fail;
4018 }
4019 {
4020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4021 }
4022 return resultobj;
4023 fail:
4024 return NULL;
4025 }
4026
4027
4028 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4029 PyObject *resultobj = NULL;
4030 wxSize *arg1 = (wxSize *) 0 ;
4031 wxSize *arg2 = 0 ;
4032 wxSize temp2 ;
4033 PyObject * obj0 = 0 ;
4034 PyObject * obj1 = 0 ;
4035 char *kwnames[] = {
4036 (char *) "self",(char *) "size", NULL
4037 };
4038
4039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4041 if (SWIG_arg_fail(1)) SWIG_fail;
4042 {
4043 arg2 = &temp2;
4044 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4045 }
4046 {
4047 PyThreadState* __tstate = wxPyBeginAllowThreads();
4048 (arg1)->SetDefaults((wxSize const &)*arg2);
4049
4050 wxPyEndAllowThreads(__tstate);
4051 if (PyErr_Occurred()) SWIG_fail;
4052 }
4053 Py_INCREF(Py_None); resultobj = Py_None;
4054 return resultobj;
4055 fail:
4056 return NULL;
4057 }
4058
4059
4060 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4061 PyObject *resultobj = NULL;
4062 wxSize *arg1 = (wxSize *) 0 ;
4063 PyObject *result;
4064 PyObject * obj0 = 0 ;
4065 char *kwnames[] = {
4066 (char *) "self", NULL
4067 };
4068
4069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4071 if (SWIG_arg_fail(1)) SWIG_fail;
4072 {
4073 PyThreadState* __tstate = wxPyBeginAllowThreads();
4074 result = (PyObject *)wxSize_Get(arg1);
4075
4076 wxPyEndAllowThreads(__tstate);
4077 if (PyErr_Occurred()) SWIG_fail;
4078 }
4079 resultobj = result;
4080 return resultobj;
4081 fail:
4082 return NULL;
4083 }
4084
4085
4086 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4087 PyObject *obj;
4088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4089 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4090 Py_INCREF(obj);
4091 return Py_BuildValue((char *)"");
4092 }
4093 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4094 PyObject *resultobj = NULL;
4095 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4096 double arg2 ;
4097 PyObject * obj0 = 0 ;
4098 PyObject * obj1 = 0 ;
4099 char *kwnames[] = {
4100 (char *) "self",(char *) "x", NULL
4101 };
4102
4103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4105 if (SWIG_arg_fail(1)) SWIG_fail;
4106 {
4107 arg2 = static_cast<double >(SWIG_As_double(obj1));
4108 if (SWIG_arg_fail(2)) SWIG_fail;
4109 }
4110 if (arg1) (arg1)->x = arg2;
4111
4112 Py_INCREF(Py_None); resultobj = Py_None;
4113 return resultobj;
4114 fail:
4115 return NULL;
4116 }
4117
4118
4119 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4120 PyObject *resultobj = NULL;
4121 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4122 double result;
4123 PyObject * obj0 = 0 ;
4124 char *kwnames[] = {
4125 (char *) "self", NULL
4126 };
4127
4128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4130 if (SWIG_arg_fail(1)) SWIG_fail;
4131 result = (double) ((arg1)->x);
4132
4133 {
4134 resultobj = SWIG_From_double(static_cast<double >(result));
4135 }
4136 return resultobj;
4137 fail:
4138 return NULL;
4139 }
4140
4141
4142 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4143 PyObject *resultobj = NULL;
4144 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4145 double arg2 ;
4146 PyObject * obj0 = 0 ;
4147 PyObject * obj1 = 0 ;
4148 char *kwnames[] = {
4149 (char *) "self",(char *) "y", NULL
4150 };
4151
4152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4154 if (SWIG_arg_fail(1)) SWIG_fail;
4155 {
4156 arg2 = static_cast<double >(SWIG_As_double(obj1));
4157 if (SWIG_arg_fail(2)) SWIG_fail;
4158 }
4159 if (arg1) (arg1)->y = arg2;
4160
4161 Py_INCREF(Py_None); resultobj = Py_None;
4162 return resultobj;
4163 fail:
4164 return NULL;
4165 }
4166
4167
4168 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4169 PyObject *resultobj = NULL;
4170 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4171 double result;
4172 PyObject * obj0 = 0 ;
4173 char *kwnames[] = {
4174 (char *) "self", NULL
4175 };
4176
4177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4179 if (SWIG_arg_fail(1)) SWIG_fail;
4180 result = (double) ((arg1)->y);
4181
4182 {
4183 resultobj = SWIG_From_double(static_cast<double >(result));
4184 }
4185 return resultobj;
4186 fail:
4187 return NULL;
4188 }
4189
4190
4191 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4192 PyObject *resultobj = NULL;
4193 double arg1 = (double) 0.0 ;
4194 double arg2 = (double) 0.0 ;
4195 wxRealPoint *result;
4196 PyObject * obj0 = 0 ;
4197 PyObject * obj1 = 0 ;
4198 char *kwnames[] = {
4199 (char *) "x",(char *) "y", NULL
4200 };
4201
4202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4203 if (obj0) {
4204 {
4205 arg1 = static_cast<double >(SWIG_As_double(obj0));
4206 if (SWIG_arg_fail(1)) SWIG_fail;
4207 }
4208 }
4209 if (obj1) {
4210 {
4211 arg2 = static_cast<double >(SWIG_As_double(obj1));
4212 if (SWIG_arg_fail(2)) SWIG_fail;
4213 }
4214 }
4215 {
4216 PyThreadState* __tstate = wxPyBeginAllowThreads();
4217 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4218
4219 wxPyEndAllowThreads(__tstate);
4220 if (PyErr_Occurred()) SWIG_fail;
4221 }
4222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4223 return resultobj;
4224 fail:
4225 return NULL;
4226 }
4227
4228
4229 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4230 PyObject *resultobj = NULL;
4231 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4232 PyObject * obj0 = 0 ;
4233 char *kwnames[] = {
4234 (char *) "self", NULL
4235 };
4236
4237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4239 if (SWIG_arg_fail(1)) SWIG_fail;
4240 {
4241 PyThreadState* __tstate = wxPyBeginAllowThreads();
4242 delete arg1;
4243
4244 wxPyEndAllowThreads(__tstate);
4245 if (PyErr_Occurred()) SWIG_fail;
4246 }
4247 Py_INCREF(Py_None); resultobj = Py_None;
4248 return resultobj;
4249 fail:
4250 return NULL;
4251 }
4252
4253
4254 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4255 PyObject *resultobj = NULL;
4256 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4257 wxRealPoint *arg2 = 0 ;
4258 bool result;
4259 wxRealPoint temp2 ;
4260 PyObject * obj0 = 0 ;
4261 PyObject * obj1 = 0 ;
4262 char *kwnames[] = {
4263 (char *) "self",(char *) "pt", NULL
4264 };
4265
4266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4268 if (SWIG_arg_fail(1)) SWIG_fail;
4269 {
4270 arg2 = &temp2;
4271 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4272 }
4273 {
4274 PyThreadState* __tstate = wxPyBeginAllowThreads();
4275 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4276
4277 wxPyEndAllowThreads(__tstate);
4278 if (PyErr_Occurred()) SWIG_fail;
4279 }
4280 {
4281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4282 }
4283 return resultobj;
4284 fail:
4285 return NULL;
4286 }
4287
4288
4289 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4290 PyObject *resultobj = NULL;
4291 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4292 wxRealPoint *arg2 = 0 ;
4293 bool result;
4294 wxRealPoint temp2 ;
4295 PyObject * obj0 = 0 ;
4296 PyObject * obj1 = 0 ;
4297 char *kwnames[] = {
4298 (char *) "self",(char *) "pt", NULL
4299 };
4300
4301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4303 if (SWIG_arg_fail(1)) SWIG_fail;
4304 {
4305 arg2 = &temp2;
4306 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4307 }
4308 {
4309 PyThreadState* __tstate = wxPyBeginAllowThreads();
4310 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4311
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 {
4316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4317 }
4318 return resultobj;
4319 fail:
4320 return NULL;
4321 }
4322
4323
4324 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4325 PyObject *resultobj = NULL;
4326 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4327 wxRealPoint *arg2 = 0 ;
4328 wxRealPoint result;
4329 wxRealPoint temp2 ;
4330 PyObject * obj0 = 0 ;
4331 PyObject * obj1 = 0 ;
4332 char *kwnames[] = {
4333 (char *) "self",(char *) "pt", NULL
4334 };
4335
4336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4338 if (SWIG_arg_fail(1)) SWIG_fail;
4339 {
4340 arg2 = &temp2;
4341 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4342 }
4343 {
4344 PyThreadState* __tstate = wxPyBeginAllowThreads();
4345 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4346
4347 wxPyEndAllowThreads(__tstate);
4348 if (PyErr_Occurred()) SWIG_fail;
4349 }
4350 {
4351 wxRealPoint * resultptr;
4352 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4354 }
4355 return resultobj;
4356 fail:
4357 return NULL;
4358 }
4359
4360
4361 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4362 PyObject *resultobj = NULL;
4363 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4364 wxRealPoint *arg2 = 0 ;
4365 wxRealPoint result;
4366 wxRealPoint temp2 ;
4367 PyObject * obj0 = 0 ;
4368 PyObject * obj1 = 0 ;
4369 char *kwnames[] = {
4370 (char *) "self",(char *) "pt", NULL
4371 };
4372
4373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4375 if (SWIG_arg_fail(1)) SWIG_fail;
4376 {
4377 arg2 = &temp2;
4378 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4379 }
4380 {
4381 PyThreadState* __tstate = wxPyBeginAllowThreads();
4382 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4383
4384 wxPyEndAllowThreads(__tstate);
4385 if (PyErr_Occurred()) SWIG_fail;
4386 }
4387 {
4388 wxRealPoint * resultptr;
4389 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4390 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4391 }
4392 return resultobj;
4393 fail:
4394 return NULL;
4395 }
4396
4397
4398 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4399 PyObject *resultobj = NULL;
4400 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4401 double arg2 ;
4402 double arg3 ;
4403 PyObject * obj0 = 0 ;
4404 PyObject * obj1 = 0 ;
4405 PyObject * obj2 = 0 ;
4406 char *kwnames[] = {
4407 (char *) "self",(char *) "x",(char *) "y", NULL
4408 };
4409
4410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4412 if (SWIG_arg_fail(1)) SWIG_fail;
4413 {
4414 arg2 = static_cast<double >(SWIG_As_double(obj1));
4415 if (SWIG_arg_fail(2)) SWIG_fail;
4416 }
4417 {
4418 arg3 = static_cast<double >(SWIG_As_double(obj2));
4419 if (SWIG_arg_fail(3)) SWIG_fail;
4420 }
4421 {
4422 PyThreadState* __tstate = wxPyBeginAllowThreads();
4423 wxRealPoint_Set(arg1,arg2,arg3);
4424
4425 wxPyEndAllowThreads(__tstate);
4426 if (PyErr_Occurred()) SWIG_fail;
4427 }
4428 Py_INCREF(Py_None); resultobj = Py_None;
4429 return resultobj;
4430 fail:
4431 return NULL;
4432 }
4433
4434
4435 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4436 PyObject *resultobj = NULL;
4437 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4438 PyObject *result;
4439 PyObject * obj0 = 0 ;
4440 char *kwnames[] = {
4441 (char *) "self", NULL
4442 };
4443
4444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4446 if (SWIG_arg_fail(1)) SWIG_fail;
4447 {
4448 PyThreadState* __tstate = wxPyBeginAllowThreads();
4449 result = (PyObject *)wxRealPoint_Get(arg1);
4450
4451 wxPyEndAllowThreads(__tstate);
4452 if (PyErr_Occurred()) SWIG_fail;
4453 }
4454 resultobj = result;
4455 return resultobj;
4456 fail:
4457 return NULL;
4458 }
4459
4460
4461 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4462 PyObject *obj;
4463 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4464 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4465 Py_INCREF(obj);
4466 return Py_BuildValue((char *)"");
4467 }
4468 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4469 PyObject *resultobj = NULL;
4470 wxPoint *arg1 = (wxPoint *) 0 ;
4471 int arg2 ;
4472 PyObject * obj0 = 0 ;
4473 PyObject * obj1 = 0 ;
4474 char *kwnames[] = {
4475 (char *) "self",(char *) "x", NULL
4476 };
4477
4478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4480 if (SWIG_arg_fail(1)) SWIG_fail;
4481 {
4482 arg2 = static_cast<int >(SWIG_As_int(obj1));
4483 if (SWIG_arg_fail(2)) SWIG_fail;
4484 }
4485 if (arg1) (arg1)->x = arg2;
4486
4487 Py_INCREF(Py_None); resultobj = Py_None;
4488 return resultobj;
4489 fail:
4490 return NULL;
4491 }
4492
4493
4494 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4495 PyObject *resultobj = NULL;
4496 wxPoint *arg1 = (wxPoint *) 0 ;
4497 int result;
4498 PyObject * obj0 = 0 ;
4499 char *kwnames[] = {
4500 (char *) "self", NULL
4501 };
4502
4503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4505 if (SWIG_arg_fail(1)) SWIG_fail;
4506 result = (int) ((arg1)->x);
4507
4508 {
4509 resultobj = SWIG_From_int(static_cast<int >(result));
4510 }
4511 return resultobj;
4512 fail:
4513 return NULL;
4514 }
4515
4516
4517 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4518 PyObject *resultobj = NULL;
4519 wxPoint *arg1 = (wxPoint *) 0 ;
4520 int arg2 ;
4521 PyObject * obj0 = 0 ;
4522 PyObject * obj1 = 0 ;
4523 char *kwnames[] = {
4524 (char *) "self",(char *) "y", NULL
4525 };
4526
4527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4529 if (SWIG_arg_fail(1)) SWIG_fail;
4530 {
4531 arg2 = static_cast<int >(SWIG_As_int(obj1));
4532 if (SWIG_arg_fail(2)) SWIG_fail;
4533 }
4534 if (arg1) (arg1)->y = arg2;
4535
4536 Py_INCREF(Py_None); resultobj = Py_None;
4537 return resultobj;
4538 fail:
4539 return NULL;
4540 }
4541
4542
4543 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4544 PyObject *resultobj = NULL;
4545 wxPoint *arg1 = (wxPoint *) 0 ;
4546 int result;
4547 PyObject * obj0 = 0 ;
4548 char *kwnames[] = {
4549 (char *) "self", NULL
4550 };
4551
4552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4554 if (SWIG_arg_fail(1)) SWIG_fail;
4555 result = (int) ((arg1)->y);
4556
4557 {
4558 resultobj = SWIG_From_int(static_cast<int >(result));
4559 }
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4567 PyObject *resultobj = NULL;
4568 int arg1 = (int) 0 ;
4569 int arg2 = (int) 0 ;
4570 wxPoint *result;
4571 PyObject * obj0 = 0 ;
4572 PyObject * obj1 = 0 ;
4573 char *kwnames[] = {
4574 (char *) "x",(char *) "y", NULL
4575 };
4576
4577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4578 if (obj0) {
4579 {
4580 arg1 = static_cast<int >(SWIG_As_int(obj0));
4581 if (SWIG_arg_fail(1)) SWIG_fail;
4582 }
4583 }
4584 if (obj1) {
4585 {
4586 arg2 = static_cast<int >(SWIG_As_int(obj1));
4587 if (SWIG_arg_fail(2)) SWIG_fail;
4588 }
4589 }
4590 {
4591 PyThreadState* __tstate = wxPyBeginAllowThreads();
4592 result = (wxPoint *)new wxPoint(arg1,arg2);
4593
4594 wxPyEndAllowThreads(__tstate);
4595 if (PyErr_Occurred()) SWIG_fail;
4596 }
4597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4598 return resultobj;
4599 fail:
4600 return NULL;
4601 }
4602
4603
4604 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4605 PyObject *resultobj = NULL;
4606 wxPoint *arg1 = (wxPoint *) 0 ;
4607 PyObject * obj0 = 0 ;
4608 char *kwnames[] = {
4609 (char *) "self", NULL
4610 };
4611
4612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4614 if (SWIG_arg_fail(1)) SWIG_fail;
4615 {
4616 PyThreadState* __tstate = wxPyBeginAllowThreads();
4617 delete arg1;
4618
4619 wxPyEndAllowThreads(__tstate);
4620 if (PyErr_Occurred()) SWIG_fail;
4621 }
4622 Py_INCREF(Py_None); resultobj = Py_None;
4623 return resultobj;
4624 fail:
4625 return NULL;
4626 }
4627
4628
4629 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4630 PyObject *resultobj = NULL;
4631 wxPoint *arg1 = (wxPoint *) 0 ;
4632 wxPoint *arg2 = 0 ;
4633 bool result;
4634 wxPoint temp2 ;
4635 PyObject * obj0 = 0 ;
4636 PyObject * obj1 = 0 ;
4637 char *kwnames[] = {
4638 (char *) "self",(char *) "pt", NULL
4639 };
4640
4641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4643 if (SWIG_arg_fail(1)) SWIG_fail;
4644 {
4645 arg2 = &temp2;
4646 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4647 }
4648 {
4649 PyThreadState* __tstate = wxPyBeginAllowThreads();
4650 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4651
4652 wxPyEndAllowThreads(__tstate);
4653 if (PyErr_Occurred()) SWIG_fail;
4654 }
4655 {
4656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4657 }
4658 return resultobj;
4659 fail:
4660 return NULL;
4661 }
4662
4663
4664 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4665 PyObject *resultobj = NULL;
4666 wxPoint *arg1 = (wxPoint *) 0 ;
4667 wxPoint *arg2 = 0 ;
4668 bool result;
4669 wxPoint temp2 ;
4670 PyObject * obj0 = 0 ;
4671 PyObject * obj1 = 0 ;
4672 char *kwnames[] = {
4673 (char *) "self",(char *) "pt", NULL
4674 };
4675
4676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4678 if (SWIG_arg_fail(1)) SWIG_fail;
4679 {
4680 arg2 = &temp2;
4681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4682 }
4683 {
4684 PyThreadState* __tstate = wxPyBeginAllowThreads();
4685 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4686
4687 wxPyEndAllowThreads(__tstate);
4688 if (PyErr_Occurred()) SWIG_fail;
4689 }
4690 {
4691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4692 }
4693 return resultobj;
4694 fail:
4695 return NULL;
4696 }
4697
4698
4699 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4700 PyObject *resultobj = NULL;
4701 wxPoint *arg1 = (wxPoint *) 0 ;
4702 wxPoint *arg2 = 0 ;
4703 wxPoint result;
4704 wxPoint temp2 ;
4705 PyObject * obj0 = 0 ;
4706 PyObject * obj1 = 0 ;
4707 char *kwnames[] = {
4708 (char *) "self",(char *) "pt", NULL
4709 };
4710
4711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4713 if (SWIG_arg_fail(1)) SWIG_fail;
4714 {
4715 arg2 = &temp2;
4716 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4717 }
4718 {
4719 PyThreadState* __tstate = wxPyBeginAllowThreads();
4720 result = (arg1)->operator +((wxPoint const &)*arg2);
4721
4722 wxPyEndAllowThreads(__tstate);
4723 if (PyErr_Occurred()) SWIG_fail;
4724 }
4725 {
4726 wxPoint * resultptr;
4727 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4729 }
4730 return resultobj;
4731 fail:
4732 return NULL;
4733 }
4734
4735
4736 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4737 PyObject *resultobj = NULL;
4738 wxPoint *arg1 = (wxPoint *) 0 ;
4739 wxPoint *arg2 = 0 ;
4740 wxPoint result;
4741 wxPoint temp2 ;
4742 PyObject * obj0 = 0 ;
4743 PyObject * obj1 = 0 ;
4744 char *kwnames[] = {
4745 (char *) "self",(char *) "pt", NULL
4746 };
4747
4748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4750 if (SWIG_arg_fail(1)) SWIG_fail;
4751 {
4752 arg2 = &temp2;
4753 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4754 }
4755 {
4756 PyThreadState* __tstate = wxPyBeginAllowThreads();
4757 result = (arg1)->operator -((wxPoint const &)*arg2);
4758
4759 wxPyEndAllowThreads(__tstate);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 {
4763 wxPoint * resultptr;
4764 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4765 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4766 }
4767 return resultobj;
4768 fail:
4769 return NULL;
4770 }
4771
4772
4773 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj = NULL;
4775 wxPoint *arg1 = (wxPoint *) 0 ;
4776 wxPoint *arg2 = 0 ;
4777 wxPoint *result;
4778 wxPoint temp2 ;
4779 PyObject * obj0 = 0 ;
4780 PyObject * obj1 = 0 ;
4781 char *kwnames[] = {
4782 (char *) "self",(char *) "pt", NULL
4783 };
4784
4785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4787 if (SWIG_arg_fail(1)) SWIG_fail;
4788 {
4789 arg2 = &temp2;
4790 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4791 }
4792 {
4793 PyThreadState* __tstate = wxPyBeginAllowThreads();
4794 {
4795 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4796 result = (wxPoint *) &_result_ref;
4797 }
4798
4799 wxPyEndAllowThreads(__tstate);
4800 if (PyErr_Occurred()) SWIG_fail;
4801 }
4802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4803 return resultobj;
4804 fail:
4805 return NULL;
4806 }
4807
4808
4809 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4810 PyObject *resultobj = NULL;
4811 wxPoint *arg1 = (wxPoint *) 0 ;
4812 wxPoint *arg2 = 0 ;
4813 wxPoint *result;
4814 wxPoint temp2 ;
4815 PyObject * obj0 = 0 ;
4816 PyObject * obj1 = 0 ;
4817 char *kwnames[] = {
4818 (char *) "self",(char *) "pt", NULL
4819 };
4820
4821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4823 if (SWIG_arg_fail(1)) SWIG_fail;
4824 {
4825 arg2 = &temp2;
4826 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4827 }
4828 {
4829 PyThreadState* __tstate = wxPyBeginAllowThreads();
4830 {
4831 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4832 result = (wxPoint *) &_result_ref;
4833 }
4834
4835 wxPyEndAllowThreads(__tstate);
4836 if (PyErr_Occurred()) SWIG_fail;
4837 }
4838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4839 return resultobj;
4840 fail:
4841 return NULL;
4842 }
4843
4844
4845 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4846 PyObject *resultobj = NULL;
4847 wxPoint *arg1 = (wxPoint *) 0 ;
4848 long arg2 ;
4849 long arg3 ;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 PyObject * obj2 = 0 ;
4853 char *kwnames[] = {
4854 (char *) "self",(char *) "x",(char *) "y", NULL
4855 };
4856
4857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4859 if (SWIG_arg_fail(1)) SWIG_fail;
4860 {
4861 arg2 = static_cast<long >(SWIG_As_long(obj1));
4862 if (SWIG_arg_fail(2)) SWIG_fail;
4863 }
4864 {
4865 arg3 = static_cast<long >(SWIG_As_long(obj2));
4866 if (SWIG_arg_fail(3)) SWIG_fail;
4867 }
4868 {
4869 PyThreadState* __tstate = wxPyBeginAllowThreads();
4870 wxPoint_Set(arg1,arg2,arg3);
4871
4872 wxPyEndAllowThreads(__tstate);
4873 if (PyErr_Occurred()) SWIG_fail;
4874 }
4875 Py_INCREF(Py_None); resultobj = Py_None;
4876 return resultobj;
4877 fail:
4878 return NULL;
4879 }
4880
4881
4882 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4883 PyObject *resultobj = NULL;
4884 wxPoint *arg1 = (wxPoint *) 0 ;
4885 PyObject *result;
4886 PyObject * obj0 = 0 ;
4887 char *kwnames[] = {
4888 (char *) "self", NULL
4889 };
4890
4891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4893 if (SWIG_arg_fail(1)) SWIG_fail;
4894 {
4895 PyThreadState* __tstate = wxPyBeginAllowThreads();
4896 result = (PyObject *)wxPoint_Get(arg1);
4897
4898 wxPyEndAllowThreads(__tstate);
4899 if (PyErr_Occurred()) SWIG_fail;
4900 }
4901 resultobj = result;
4902 return resultobj;
4903 fail:
4904 return NULL;
4905 }
4906
4907
4908 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4909 PyObject *obj;
4910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4911 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4912 Py_INCREF(obj);
4913 return Py_BuildValue((char *)"");
4914 }
4915 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4916 PyObject *resultobj = NULL;
4917 int arg1 = (int) 0 ;
4918 int arg2 = (int) 0 ;
4919 int arg3 = (int) 0 ;
4920 int arg4 = (int) 0 ;
4921 wxRect *result;
4922 PyObject * obj0 = 0 ;
4923 PyObject * obj1 = 0 ;
4924 PyObject * obj2 = 0 ;
4925 PyObject * obj3 = 0 ;
4926 char *kwnames[] = {
4927 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4928 };
4929
4930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4931 if (obj0) {
4932 {
4933 arg1 = static_cast<int >(SWIG_As_int(obj0));
4934 if (SWIG_arg_fail(1)) SWIG_fail;
4935 }
4936 }
4937 if (obj1) {
4938 {
4939 arg2 = static_cast<int >(SWIG_As_int(obj1));
4940 if (SWIG_arg_fail(2)) SWIG_fail;
4941 }
4942 }
4943 if (obj2) {
4944 {
4945 arg3 = static_cast<int >(SWIG_As_int(obj2));
4946 if (SWIG_arg_fail(3)) SWIG_fail;
4947 }
4948 }
4949 if (obj3) {
4950 {
4951 arg4 = static_cast<int >(SWIG_As_int(obj3));
4952 if (SWIG_arg_fail(4)) SWIG_fail;
4953 }
4954 }
4955 {
4956 PyThreadState* __tstate = wxPyBeginAllowThreads();
4957 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4958
4959 wxPyEndAllowThreads(__tstate);
4960 if (PyErr_Occurred()) SWIG_fail;
4961 }
4962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4963 return resultobj;
4964 fail:
4965 return NULL;
4966 }
4967
4968
4969 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4970 PyObject *resultobj = NULL;
4971 wxPoint *arg1 = 0 ;
4972 wxPoint *arg2 = 0 ;
4973 wxRect *result;
4974 wxPoint temp1 ;
4975 wxPoint temp2 ;
4976 PyObject * obj0 = 0 ;
4977 PyObject * obj1 = 0 ;
4978 char *kwnames[] = {
4979 (char *) "topLeft",(char *) "bottomRight", NULL
4980 };
4981
4982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4983 {
4984 arg1 = &temp1;
4985 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4986 }
4987 {
4988 arg2 = &temp2;
4989 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4990 }
4991 {
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4994
4995 wxPyEndAllowThreads(__tstate);
4996 if (PyErr_Occurred()) SWIG_fail;
4997 }
4998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4999 return resultobj;
5000 fail:
5001 return NULL;
5002 }
5003
5004
5005 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
5006 PyObject *resultobj = NULL;
5007 wxPoint *arg1 = 0 ;
5008 wxSize *arg2 = 0 ;
5009 wxRect *result;
5010 wxPoint temp1 ;
5011 wxSize temp2 ;
5012 PyObject * obj0 = 0 ;
5013 PyObject * obj1 = 0 ;
5014 char *kwnames[] = {
5015 (char *) "pos",(char *) "size", NULL
5016 };
5017
5018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5019 {
5020 arg1 = &temp1;
5021 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5022 }
5023 {
5024 arg2 = &temp2;
5025 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5026 }
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5030
5031 wxPyEndAllowThreads(__tstate);
5032 if (PyErr_Occurred()) SWIG_fail;
5033 }
5034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5035 return resultobj;
5036 fail:
5037 return NULL;
5038 }
5039
5040
5041 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5042 PyObject *resultobj = NULL;
5043 wxSize *arg1 = 0 ;
5044 wxRect *result;
5045 wxSize temp1 ;
5046 PyObject * obj0 = 0 ;
5047 char *kwnames[] = {
5048 (char *) "size", NULL
5049 };
5050
5051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5052 {
5053 arg1 = &temp1;
5054 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5055 }
5056 {
5057 PyThreadState* __tstate = wxPyBeginAllowThreads();
5058 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5059
5060 wxPyEndAllowThreads(__tstate);
5061 if (PyErr_Occurred()) SWIG_fail;
5062 }
5063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5064 return resultobj;
5065 fail:
5066 return NULL;
5067 }
5068
5069
5070 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5071 PyObject *resultobj = NULL;
5072 wxRect *arg1 = (wxRect *) 0 ;
5073 PyObject * obj0 = 0 ;
5074 char *kwnames[] = {
5075 (char *) "self", NULL
5076 };
5077
5078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5080 if (SWIG_arg_fail(1)) SWIG_fail;
5081 {
5082 PyThreadState* __tstate = wxPyBeginAllowThreads();
5083 delete arg1;
5084
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 Py_INCREF(Py_None); resultobj = Py_None;
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5096 PyObject *resultobj = NULL;
5097 wxRect *arg1 = (wxRect *) 0 ;
5098 int result;
5099 PyObject * obj0 = 0 ;
5100 char *kwnames[] = {
5101 (char *) "self", NULL
5102 };
5103
5104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5106 if (SWIG_arg_fail(1)) SWIG_fail;
5107 {
5108 PyThreadState* __tstate = wxPyBeginAllowThreads();
5109 result = (int)((wxRect const *)arg1)->GetX();
5110
5111 wxPyEndAllowThreads(__tstate);
5112 if (PyErr_Occurred()) SWIG_fail;
5113 }
5114 {
5115 resultobj = SWIG_From_int(static_cast<int >(result));
5116 }
5117 return resultobj;
5118 fail:
5119 return NULL;
5120 }
5121
5122
5123 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5124 PyObject *resultobj = NULL;
5125 wxRect *arg1 = (wxRect *) 0 ;
5126 int arg2 ;
5127 PyObject * obj0 = 0 ;
5128 PyObject * obj1 = 0 ;
5129 char *kwnames[] = {
5130 (char *) "self",(char *) "x", NULL
5131 };
5132
5133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5135 if (SWIG_arg_fail(1)) SWIG_fail;
5136 {
5137 arg2 = static_cast<int >(SWIG_As_int(obj1));
5138 if (SWIG_arg_fail(2)) SWIG_fail;
5139 }
5140 {
5141 PyThreadState* __tstate = wxPyBeginAllowThreads();
5142 (arg1)->SetX(arg2);
5143
5144 wxPyEndAllowThreads(__tstate);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 Py_INCREF(Py_None); resultobj = Py_None;
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5155 PyObject *resultobj = NULL;
5156 wxRect *arg1 = (wxRect *) 0 ;
5157 int result;
5158 PyObject * obj0 = 0 ;
5159 char *kwnames[] = {
5160 (char *) "self", NULL
5161 };
5162
5163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5165 if (SWIG_arg_fail(1)) SWIG_fail;
5166 {
5167 PyThreadState* __tstate = wxPyBeginAllowThreads();
5168 result = (int)(arg1)->GetY();
5169
5170 wxPyEndAllowThreads(__tstate);
5171 if (PyErr_Occurred()) SWIG_fail;
5172 }
5173 {
5174 resultobj = SWIG_From_int(static_cast<int >(result));
5175 }
5176 return resultobj;
5177 fail:
5178 return NULL;
5179 }
5180
5181
5182 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5183 PyObject *resultobj = NULL;
5184 wxRect *arg1 = (wxRect *) 0 ;
5185 int arg2 ;
5186 PyObject * obj0 = 0 ;
5187 PyObject * obj1 = 0 ;
5188 char *kwnames[] = {
5189 (char *) "self",(char *) "y", NULL
5190 };
5191
5192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5194 if (SWIG_arg_fail(1)) SWIG_fail;
5195 {
5196 arg2 = static_cast<int >(SWIG_As_int(obj1));
5197 if (SWIG_arg_fail(2)) SWIG_fail;
5198 }
5199 {
5200 PyThreadState* __tstate = wxPyBeginAllowThreads();
5201 (arg1)->SetY(arg2);
5202
5203 wxPyEndAllowThreads(__tstate);
5204 if (PyErr_Occurred()) SWIG_fail;
5205 }
5206 Py_INCREF(Py_None); resultobj = Py_None;
5207 return resultobj;
5208 fail:
5209 return NULL;
5210 }
5211
5212
5213 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5214 PyObject *resultobj = NULL;
5215 wxRect *arg1 = (wxRect *) 0 ;
5216 int result;
5217 PyObject * obj0 = 0 ;
5218 char *kwnames[] = {
5219 (char *) "self", NULL
5220 };
5221
5222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5224 if (SWIG_arg_fail(1)) SWIG_fail;
5225 {
5226 PyThreadState* __tstate = wxPyBeginAllowThreads();
5227 result = (int)((wxRect const *)arg1)->GetWidth();
5228
5229 wxPyEndAllowThreads(__tstate);
5230 if (PyErr_Occurred()) SWIG_fail;
5231 }
5232 {
5233 resultobj = SWIG_From_int(static_cast<int >(result));
5234 }
5235 return resultobj;
5236 fail:
5237 return NULL;
5238 }
5239
5240
5241 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5242 PyObject *resultobj = NULL;
5243 wxRect *arg1 = (wxRect *) 0 ;
5244 int arg2 ;
5245 PyObject * obj0 = 0 ;
5246 PyObject * obj1 = 0 ;
5247 char *kwnames[] = {
5248 (char *) "self",(char *) "w", NULL
5249 };
5250
5251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5253 if (SWIG_arg_fail(1)) SWIG_fail;
5254 {
5255 arg2 = static_cast<int >(SWIG_As_int(obj1));
5256 if (SWIG_arg_fail(2)) SWIG_fail;
5257 }
5258 {
5259 PyThreadState* __tstate = wxPyBeginAllowThreads();
5260 (arg1)->SetWidth(arg2);
5261
5262 wxPyEndAllowThreads(__tstate);
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 Py_INCREF(Py_None); resultobj = Py_None;
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5273 PyObject *resultobj = NULL;
5274 wxRect *arg1 = (wxRect *) 0 ;
5275 int result;
5276 PyObject * obj0 = 0 ;
5277 char *kwnames[] = {
5278 (char *) "self", NULL
5279 };
5280
5281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5283 if (SWIG_arg_fail(1)) SWIG_fail;
5284 {
5285 PyThreadState* __tstate = wxPyBeginAllowThreads();
5286 result = (int)((wxRect const *)arg1)->GetHeight();
5287
5288 wxPyEndAllowThreads(__tstate);
5289 if (PyErr_Occurred()) SWIG_fail;
5290 }
5291 {
5292 resultobj = SWIG_From_int(static_cast<int >(result));
5293 }
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = NULL;
5302 wxRect *arg1 = (wxRect *) 0 ;
5303 int arg2 ;
5304 PyObject * obj0 = 0 ;
5305 PyObject * obj1 = 0 ;
5306 char *kwnames[] = {
5307 (char *) "self",(char *) "h", NULL
5308 };
5309
5310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5312 if (SWIG_arg_fail(1)) SWIG_fail;
5313 {
5314 arg2 = static_cast<int >(SWIG_As_int(obj1));
5315 if (SWIG_arg_fail(2)) SWIG_fail;
5316 }
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 (arg1)->SetHeight(arg2);
5320
5321 wxPyEndAllowThreads(__tstate);
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 Py_INCREF(Py_None); resultobj = Py_None;
5325 return resultobj;
5326 fail:
5327 return NULL;
5328 }
5329
5330
5331 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5332 PyObject *resultobj = NULL;
5333 wxRect *arg1 = (wxRect *) 0 ;
5334 wxPoint result;
5335 PyObject * obj0 = 0 ;
5336 char *kwnames[] = {
5337 (char *) "self", NULL
5338 };
5339
5340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5342 if (SWIG_arg_fail(1)) SWIG_fail;
5343 {
5344 PyThreadState* __tstate = wxPyBeginAllowThreads();
5345 result = ((wxRect const *)arg1)->GetPosition();
5346
5347 wxPyEndAllowThreads(__tstate);
5348 if (PyErr_Occurred()) SWIG_fail;
5349 }
5350 {
5351 wxPoint * resultptr;
5352 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5353 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5354 }
5355 return resultobj;
5356 fail:
5357 return NULL;
5358 }
5359
5360
5361 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5362 PyObject *resultobj = NULL;
5363 wxRect *arg1 = (wxRect *) 0 ;
5364 wxPoint *arg2 = 0 ;
5365 wxPoint temp2 ;
5366 PyObject * obj0 = 0 ;
5367 PyObject * obj1 = 0 ;
5368 char *kwnames[] = {
5369 (char *) "self",(char *) "p", NULL
5370 };
5371
5372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5374 if (SWIG_arg_fail(1)) SWIG_fail;
5375 {
5376 arg2 = &temp2;
5377 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5378 }
5379 {
5380 PyThreadState* __tstate = wxPyBeginAllowThreads();
5381 (arg1)->SetPosition((wxPoint const &)*arg2);
5382
5383 wxPyEndAllowThreads(__tstate);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 Py_INCREF(Py_None); resultobj = Py_None;
5387 return resultobj;
5388 fail:
5389 return NULL;
5390 }
5391
5392
5393 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5394 PyObject *resultobj = NULL;
5395 wxRect *arg1 = (wxRect *) 0 ;
5396 wxSize result;
5397 PyObject * obj0 = 0 ;
5398 char *kwnames[] = {
5399 (char *) "self", NULL
5400 };
5401
5402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5404 if (SWIG_arg_fail(1)) SWIG_fail;
5405 {
5406 PyThreadState* __tstate = wxPyBeginAllowThreads();
5407 result = ((wxRect const *)arg1)->GetSize();
5408
5409 wxPyEndAllowThreads(__tstate);
5410 if (PyErr_Occurred()) SWIG_fail;
5411 }
5412 {
5413 wxSize * resultptr;
5414 resultptr = new wxSize(static_cast<wxSize & >(result));
5415 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5416 }
5417 return resultobj;
5418 fail:
5419 return NULL;
5420 }
5421
5422
5423 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5424 PyObject *resultobj = NULL;
5425 wxRect *arg1 = (wxRect *) 0 ;
5426 wxSize *arg2 = 0 ;
5427 wxSize temp2 ;
5428 PyObject * obj0 = 0 ;
5429 PyObject * obj1 = 0 ;
5430 char *kwnames[] = {
5431 (char *) "self",(char *) "s", NULL
5432 };
5433
5434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5436 if (SWIG_arg_fail(1)) SWIG_fail;
5437 {
5438 arg2 = &temp2;
5439 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5440 }
5441 {
5442 PyThreadState* __tstate = wxPyBeginAllowThreads();
5443 (arg1)->SetSize((wxSize const &)*arg2);
5444
5445 wxPyEndAllowThreads(__tstate);
5446 if (PyErr_Occurred()) SWIG_fail;
5447 }
5448 Py_INCREF(Py_None); resultobj = Py_None;
5449 return resultobj;
5450 fail:
5451 return NULL;
5452 }
5453
5454
5455 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5456 PyObject *resultobj = NULL;
5457 wxRect *arg1 = (wxRect *) 0 ;
5458 bool result;
5459 PyObject * obj0 = 0 ;
5460 char *kwnames[] = {
5461 (char *) "self", NULL
5462 };
5463
5464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5466 if (SWIG_arg_fail(1)) SWIG_fail;
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 result = (bool)((wxRect const *)arg1)->IsEmpty();
5470
5471 wxPyEndAllowThreads(__tstate);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 {
5475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5476 }
5477 return resultobj;
5478 fail:
5479 return NULL;
5480 }
5481
5482
5483 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5484 PyObject *resultobj = NULL;
5485 wxRect *arg1 = (wxRect *) 0 ;
5486 wxPoint result;
5487 PyObject * obj0 = 0 ;
5488 char *kwnames[] = {
5489 (char *) "self", NULL
5490 };
5491
5492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5494 if (SWIG_arg_fail(1)) SWIG_fail;
5495 {
5496 PyThreadState* __tstate = wxPyBeginAllowThreads();
5497 result = ((wxRect const *)arg1)->GetTopLeft();
5498
5499 wxPyEndAllowThreads(__tstate);
5500 if (PyErr_Occurred()) SWIG_fail;
5501 }
5502 {
5503 wxPoint * resultptr;
5504 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5505 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5506 }
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5514 PyObject *resultobj = NULL;
5515 wxRect *arg1 = (wxRect *) 0 ;
5516 wxPoint *arg2 = 0 ;
5517 wxPoint temp2 ;
5518 PyObject * obj0 = 0 ;
5519 PyObject * obj1 = 0 ;
5520 char *kwnames[] = {
5521 (char *) "self",(char *) "p", NULL
5522 };
5523
5524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5526 if (SWIG_arg_fail(1)) SWIG_fail;
5527 {
5528 arg2 = &temp2;
5529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5530 }
5531 {
5532 PyThreadState* __tstate = wxPyBeginAllowThreads();
5533 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5534
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 Py_INCREF(Py_None); resultobj = Py_None;
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
5545 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5546 PyObject *resultobj = NULL;
5547 wxRect *arg1 = (wxRect *) 0 ;
5548 wxPoint result;
5549 PyObject * obj0 = 0 ;
5550 char *kwnames[] = {
5551 (char *) "self", NULL
5552 };
5553
5554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5556 if (SWIG_arg_fail(1)) SWIG_fail;
5557 {
5558 PyThreadState* __tstate = wxPyBeginAllowThreads();
5559 result = ((wxRect const *)arg1)->GetBottomRight();
5560
5561 wxPyEndAllowThreads(__tstate);
5562 if (PyErr_Occurred()) SWIG_fail;
5563 }
5564 {
5565 wxPoint * resultptr;
5566 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5568 }
5569 return resultobj;
5570 fail:
5571 return NULL;
5572 }
5573
5574
5575 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5576 PyObject *resultobj = NULL;
5577 wxRect *arg1 = (wxRect *) 0 ;
5578 wxPoint *arg2 = 0 ;
5579 wxPoint temp2 ;
5580 PyObject * obj0 = 0 ;
5581 PyObject * obj1 = 0 ;
5582 char *kwnames[] = {
5583 (char *) "self",(char *) "p", NULL
5584 };
5585
5586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5588 if (SWIG_arg_fail(1)) SWIG_fail;
5589 {
5590 arg2 = &temp2;
5591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5592 }
5593 {
5594 PyThreadState* __tstate = wxPyBeginAllowThreads();
5595 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5596
5597 wxPyEndAllowThreads(__tstate);
5598 if (PyErr_Occurred()) SWIG_fail;
5599 }
5600 Py_INCREF(Py_None); resultobj = Py_None;
5601 return resultobj;
5602 fail:
5603 return NULL;
5604 }
5605
5606
5607 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5608 PyObject *resultobj = NULL;
5609 wxRect *arg1 = (wxRect *) 0 ;
5610 int result;
5611 PyObject * obj0 = 0 ;
5612 char *kwnames[] = {
5613 (char *) "self", NULL
5614 };
5615
5616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5618 if (SWIG_arg_fail(1)) SWIG_fail;
5619 {
5620 PyThreadState* __tstate = wxPyBeginAllowThreads();
5621 result = (int)((wxRect const *)arg1)->GetLeft();
5622
5623 wxPyEndAllowThreads(__tstate);
5624 if (PyErr_Occurred()) SWIG_fail;
5625 }
5626 {
5627 resultobj = SWIG_From_int(static_cast<int >(result));
5628 }
5629 return resultobj;
5630 fail:
5631 return NULL;
5632 }
5633
5634
5635 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5636 PyObject *resultobj = NULL;
5637 wxRect *arg1 = (wxRect *) 0 ;
5638 int result;
5639 PyObject * obj0 = 0 ;
5640 char *kwnames[] = {
5641 (char *) "self", NULL
5642 };
5643
5644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5646 if (SWIG_arg_fail(1)) SWIG_fail;
5647 {
5648 PyThreadState* __tstate = wxPyBeginAllowThreads();
5649 result = (int)((wxRect const *)arg1)->GetTop();
5650
5651 wxPyEndAllowThreads(__tstate);
5652 if (PyErr_Occurred()) SWIG_fail;
5653 }
5654 {
5655 resultobj = SWIG_From_int(static_cast<int >(result));
5656 }
5657 return resultobj;
5658 fail:
5659 return NULL;
5660 }
5661
5662
5663 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5664 PyObject *resultobj = NULL;
5665 wxRect *arg1 = (wxRect *) 0 ;
5666 int result;
5667 PyObject * obj0 = 0 ;
5668 char *kwnames[] = {
5669 (char *) "self", NULL
5670 };
5671
5672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5674 if (SWIG_arg_fail(1)) SWIG_fail;
5675 {
5676 PyThreadState* __tstate = wxPyBeginAllowThreads();
5677 result = (int)((wxRect const *)arg1)->GetBottom();
5678
5679 wxPyEndAllowThreads(__tstate);
5680 if (PyErr_Occurred()) SWIG_fail;
5681 }
5682 {
5683 resultobj = SWIG_From_int(static_cast<int >(result));
5684 }
5685 return resultobj;
5686 fail:
5687 return NULL;
5688 }
5689
5690
5691 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5692 PyObject *resultobj = NULL;
5693 wxRect *arg1 = (wxRect *) 0 ;
5694 int result;
5695 PyObject * obj0 = 0 ;
5696 char *kwnames[] = {
5697 (char *) "self", NULL
5698 };
5699
5700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5702 if (SWIG_arg_fail(1)) SWIG_fail;
5703 {
5704 PyThreadState* __tstate = wxPyBeginAllowThreads();
5705 result = (int)((wxRect const *)arg1)->GetRight();
5706
5707 wxPyEndAllowThreads(__tstate);
5708 if (PyErr_Occurred()) SWIG_fail;
5709 }
5710 {
5711 resultobj = SWIG_From_int(static_cast<int >(result));
5712 }
5713 return resultobj;
5714 fail:
5715 return NULL;
5716 }
5717
5718
5719 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5720 PyObject *resultobj = NULL;
5721 wxRect *arg1 = (wxRect *) 0 ;
5722 int arg2 ;
5723 PyObject * obj0 = 0 ;
5724 PyObject * obj1 = 0 ;
5725 char *kwnames[] = {
5726 (char *) "self",(char *) "left", NULL
5727 };
5728
5729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5731 if (SWIG_arg_fail(1)) SWIG_fail;
5732 {
5733 arg2 = static_cast<int >(SWIG_As_int(obj1));
5734 if (SWIG_arg_fail(2)) SWIG_fail;
5735 }
5736 {
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 (arg1)->SetLeft(arg2);
5739
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 Py_INCREF(Py_None); resultobj = Py_None;
5744 return resultobj;
5745 fail:
5746 return NULL;
5747 }
5748
5749
5750 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5751 PyObject *resultobj = NULL;
5752 wxRect *arg1 = (wxRect *) 0 ;
5753 int arg2 ;
5754 PyObject * obj0 = 0 ;
5755 PyObject * obj1 = 0 ;
5756 char *kwnames[] = {
5757 (char *) "self",(char *) "right", NULL
5758 };
5759
5760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5762 if (SWIG_arg_fail(1)) SWIG_fail;
5763 {
5764 arg2 = static_cast<int >(SWIG_As_int(obj1));
5765 if (SWIG_arg_fail(2)) SWIG_fail;
5766 }
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 (arg1)->SetRight(arg2);
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 Py_INCREF(Py_None); resultobj = Py_None;
5775 return resultobj;
5776 fail:
5777 return NULL;
5778 }
5779
5780
5781 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5782 PyObject *resultobj = NULL;
5783 wxRect *arg1 = (wxRect *) 0 ;
5784 int arg2 ;
5785 PyObject * obj0 = 0 ;
5786 PyObject * obj1 = 0 ;
5787 char *kwnames[] = {
5788 (char *) "self",(char *) "top", NULL
5789 };
5790
5791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5793 if (SWIG_arg_fail(1)) SWIG_fail;
5794 {
5795 arg2 = static_cast<int >(SWIG_As_int(obj1));
5796 if (SWIG_arg_fail(2)) SWIG_fail;
5797 }
5798 {
5799 PyThreadState* __tstate = wxPyBeginAllowThreads();
5800 (arg1)->SetTop(arg2);
5801
5802 wxPyEndAllowThreads(__tstate);
5803 if (PyErr_Occurred()) SWIG_fail;
5804 }
5805 Py_INCREF(Py_None); resultobj = Py_None;
5806 return resultobj;
5807 fail:
5808 return NULL;
5809 }
5810
5811
5812 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5813 PyObject *resultobj = NULL;
5814 wxRect *arg1 = (wxRect *) 0 ;
5815 int arg2 ;
5816 PyObject * obj0 = 0 ;
5817 PyObject * obj1 = 0 ;
5818 char *kwnames[] = {
5819 (char *) "self",(char *) "bottom", NULL
5820 };
5821
5822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5824 if (SWIG_arg_fail(1)) SWIG_fail;
5825 {
5826 arg2 = static_cast<int >(SWIG_As_int(obj1));
5827 if (SWIG_arg_fail(2)) SWIG_fail;
5828 }
5829 {
5830 PyThreadState* __tstate = wxPyBeginAllowThreads();
5831 (arg1)->SetBottom(arg2);
5832
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 Py_INCREF(Py_None); resultobj = Py_None;
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj = NULL;
5845 wxRect *arg1 = (wxRect *) 0 ;
5846 int arg2 ;
5847 int arg3 ;
5848 wxRect *result;
5849 PyObject * obj0 = 0 ;
5850 PyObject * obj1 = 0 ;
5851 PyObject * obj2 = 0 ;
5852 char *kwnames[] = {
5853 (char *) "self",(char *) "dx",(char *) "dy", NULL
5854 };
5855
5856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5858 if (SWIG_arg_fail(1)) SWIG_fail;
5859 {
5860 arg2 = static_cast<int >(SWIG_As_int(obj1));
5861 if (SWIG_arg_fail(2)) SWIG_fail;
5862 }
5863 {
5864 arg3 = static_cast<int >(SWIG_As_int(obj2));
5865 if (SWIG_arg_fail(3)) SWIG_fail;
5866 }
5867 {
5868 PyThreadState* __tstate = wxPyBeginAllowThreads();
5869 {
5870 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5871 result = (wxRect *) &_result_ref;
5872 }
5873
5874 wxPyEndAllowThreads(__tstate);
5875 if (PyErr_Occurred()) SWIG_fail;
5876 }
5877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5878 return resultobj;
5879 fail:
5880 return NULL;
5881 }
5882
5883
5884 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5885 PyObject *resultobj = NULL;
5886 wxRect *arg1 = (wxRect *) 0 ;
5887 int arg2 ;
5888 int arg3 ;
5889 wxRect *result;
5890 PyObject * obj0 = 0 ;
5891 PyObject * obj1 = 0 ;
5892 PyObject * obj2 = 0 ;
5893 char *kwnames[] = {
5894 (char *) "self",(char *) "dx",(char *) "dy", NULL
5895 };
5896
5897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5899 if (SWIG_arg_fail(1)) SWIG_fail;
5900 {
5901 arg2 = static_cast<int >(SWIG_As_int(obj1));
5902 if (SWIG_arg_fail(2)) SWIG_fail;
5903 }
5904 {
5905 arg3 = static_cast<int >(SWIG_As_int(obj2));
5906 if (SWIG_arg_fail(3)) SWIG_fail;
5907 }
5908 {
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 {
5911 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5912 result = (wxRect *) &_result_ref;
5913 }
5914
5915 wxPyEndAllowThreads(__tstate);
5916 if (PyErr_Occurred()) SWIG_fail;
5917 }
5918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5919 return resultobj;
5920 fail:
5921 return NULL;
5922 }
5923
5924
5925 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5926 PyObject *resultobj = NULL;
5927 wxRect *arg1 = (wxRect *) 0 ;
5928 int arg2 ;
5929 int arg3 ;
5930 PyObject * obj0 = 0 ;
5931 PyObject * obj1 = 0 ;
5932 PyObject * obj2 = 0 ;
5933 char *kwnames[] = {
5934 (char *) "self",(char *) "dx",(char *) "dy", NULL
5935 };
5936
5937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5939 if (SWIG_arg_fail(1)) SWIG_fail;
5940 {
5941 arg2 = static_cast<int >(SWIG_As_int(obj1));
5942 if (SWIG_arg_fail(2)) SWIG_fail;
5943 }
5944 {
5945 arg3 = static_cast<int >(SWIG_As_int(obj2));
5946 if (SWIG_arg_fail(3)) SWIG_fail;
5947 }
5948 {
5949 PyThreadState* __tstate = wxPyBeginAllowThreads();
5950 (arg1)->Offset(arg2,arg3);
5951
5952 wxPyEndAllowThreads(__tstate);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 Py_INCREF(Py_None); resultobj = Py_None;
5956 return resultobj;
5957 fail:
5958 return NULL;
5959 }
5960
5961
5962 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj = NULL;
5964 wxRect *arg1 = (wxRect *) 0 ;
5965 wxPoint *arg2 = 0 ;
5966 wxPoint temp2 ;
5967 PyObject * obj0 = 0 ;
5968 PyObject * obj1 = 0 ;
5969 char *kwnames[] = {
5970 (char *) "self",(char *) "pt", NULL
5971 };
5972
5973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5975 if (SWIG_arg_fail(1)) SWIG_fail;
5976 {
5977 arg2 = &temp2;
5978 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5979 }
5980 {
5981 PyThreadState* __tstate = wxPyBeginAllowThreads();
5982 (arg1)->Offset((wxPoint const &)*arg2);
5983
5984 wxPyEndAllowThreads(__tstate);
5985 if (PyErr_Occurred()) SWIG_fail;
5986 }
5987 Py_INCREF(Py_None); resultobj = Py_None;
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj = NULL;
5996 wxRect *arg1 = (wxRect *) 0 ;
5997 wxRect *arg2 = 0 ;
5998 wxRect result;
5999 wxRect temp2 ;
6000 PyObject * obj0 = 0 ;
6001 PyObject * obj1 = 0 ;
6002 char *kwnames[] = {
6003 (char *) "self",(char *) "rect", NULL
6004 };
6005
6006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
6007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6008 if (SWIG_arg_fail(1)) SWIG_fail;
6009 {
6010 arg2 = &temp2;
6011 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6012 }
6013 {
6014 PyThreadState* __tstate = wxPyBeginAllowThreads();
6015 result = (arg1)->Intersect((wxRect const &)*arg2);
6016
6017 wxPyEndAllowThreads(__tstate);
6018 if (PyErr_Occurred()) SWIG_fail;
6019 }
6020 {
6021 wxRect * resultptr;
6022 resultptr = new wxRect(static_cast<wxRect & >(result));
6023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6024 }
6025 return resultobj;
6026 fail:
6027 return NULL;
6028 }
6029
6030
6031 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6032 PyObject *resultobj = NULL;
6033 wxRect *arg1 = (wxRect *) 0 ;
6034 wxRect *arg2 = 0 ;
6035 wxRect result;
6036 wxRect temp2 ;
6037 PyObject * obj0 = 0 ;
6038 PyObject * obj1 = 0 ;
6039 char *kwnames[] = {
6040 (char *) "self",(char *) "rect", NULL
6041 };
6042
6043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6045 if (SWIG_arg_fail(1)) SWIG_fail;
6046 {
6047 arg2 = &temp2;
6048 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6049 }
6050 {
6051 PyThreadState* __tstate = wxPyBeginAllowThreads();
6052 result = (arg1)->Union((wxRect const &)*arg2);
6053
6054 wxPyEndAllowThreads(__tstate);
6055 if (PyErr_Occurred()) SWIG_fail;
6056 }
6057 {
6058 wxRect * resultptr;
6059 resultptr = new wxRect(static_cast<wxRect & >(result));
6060 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6061 }
6062 return resultobj;
6063 fail:
6064 return NULL;
6065 }
6066
6067
6068 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6069 PyObject *resultobj = NULL;
6070 wxRect *arg1 = (wxRect *) 0 ;
6071 wxRect *arg2 = 0 ;
6072 wxRect result;
6073 wxRect temp2 ;
6074 PyObject * obj0 = 0 ;
6075 PyObject * obj1 = 0 ;
6076 char *kwnames[] = {
6077 (char *) "self",(char *) "rect", NULL
6078 };
6079
6080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6082 if (SWIG_arg_fail(1)) SWIG_fail;
6083 {
6084 arg2 = &temp2;
6085 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6086 }
6087 {
6088 PyThreadState* __tstate = wxPyBeginAllowThreads();
6089 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6090
6091 wxPyEndAllowThreads(__tstate);
6092 if (PyErr_Occurred()) SWIG_fail;
6093 }
6094 {
6095 wxRect * resultptr;
6096 resultptr = new wxRect(static_cast<wxRect & >(result));
6097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6098 }
6099 return resultobj;
6100 fail:
6101 return NULL;
6102 }
6103
6104
6105 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6106 PyObject *resultobj = NULL;
6107 wxRect *arg1 = (wxRect *) 0 ;
6108 wxRect *arg2 = 0 ;
6109 wxRect *result;
6110 wxRect temp2 ;
6111 PyObject * obj0 = 0 ;
6112 PyObject * obj1 = 0 ;
6113 char *kwnames[] = {
6114 (char *) "self",(char *) "rect", NULL
6115 };
6116
6117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6119 if (SWIG_arg_fail(1)) SWIG_fail;
6120 {
6121 arg2 = &temp2;
6122 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6123 }
6124 {
6125 PyThreadState* __tstate = wxPyBeginAllowThreads();
6126 {
6127 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6128 result = (wxRect *) &_result_ref;
6129 }
6130
6131 wxPyEndAllowThreads(__tstate);
6132 if (PyErr_Occurred()) SWIG_fail;
6133 }
6134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6135 return resultobj;
6136 fail:
6137 return NULL;
6138 }
6139
6140
6141 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6142 PyObject *resultobj = NULL;
6143 wxRect *arg1 = (wxRect *) 0 ;
6144 wxRect *arg2 = 0 ;
6145 bool result;
6146 wxRect temp2 ;
6147 PyObject * obj0 = 0 ;
6148 PyObject * obj1 = 0 ;
6149 char *kwnames[] = {
6150 (char *) "self",(char *) "rect", NULL
6151 };
6152
6153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6155 if (SWIG_arg_fail(1)) SWIG_fail;
6156 {
6157 arg2 = &temp2;
6158 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6159 }
6160 {
6161 PyThreadState* __tstate = wxPyBeginAllowThreads();
6162 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6163
6164 wxPyEndAllowThreads(__tstate);
6165 if (PyErr_Occurred()) SWIG_fail;
6166 }
6167 {
6168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6169 }
6170 return resultobj;
6171 fail:
6172 return NULL;
6173 }
6174
6175
6176 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6177 PyObject *resultobj = NULL;
6178 wxRect *arg1 = (wxRect *) 0 ;
6179 wxRect *arg2 = 0 ;
6180 bool result;
6181 wxRect temp2 ;
6182 PyObject * obj0 = 0 ;
6183 PyObject * obj1 = 0 ;
6184 char *kwnames[] = {
6185 (char *) "self",(char *) "rect", NULL
6186 };
6187
6188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6190 if (SWIG_arg_fail(1)) SWIG_fail;
6191 {
6192 arg2 = &temp2;
6193 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6194 }
6195 {
6196 PyThreadState* __tstate = wxPyBeginAllowThreads();
6197 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6198
6199 wxPyEndAllowThreads(__tstate);
6200 if (PyErr_Occurred()) SWIG_fail;
6201 }
6202 {
6203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6204 }
6205 return resultobj;
6206 fail:
6207 return NULL;
6208 }
6209
6210
6211 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj = NULL;
6213 wxRect *arg1 = (wxRect *) 0 ;
6214 int arg2 ;
6215 int arg3 ;
6216 bool result;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 PyObject * obj2 = 0 ;
6220 char *kwnames[] = {
6221 (char *) "self",(char *) "x",(char *) "y", NULL
6222 };
6223
6224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6226 if (SWIG_arg_fail(1)) SWIG_fail;
6227 {
6228 arg2 = static_cast<int >(SWIG_As_int(obj1));
6229 if (SWIG_arg_fail(2)) SWIG_fail;
6230 }
6231 {
6232 arg3 = static_cast<int >(SWIG_As_int(obj2));
6233 if (SWIG_arg_fail(3)) SWIG_fail;
6234 }
6235 {
6236 PyThreadState* __tstate = wxPyBeginAllowThreads();
6237 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6238
6239 wxPyEndAllowThreads(__tstate);
6240 if (PyErr_Occurred()) SWIG_fail;
6241 }
6242 {
6243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6244 }
6245 return resultobj;
6246 fail:
6247 return NULL;
6248 }
6249
6250
6251 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6252 PyObject *resultobj = NULL;
6253 wxRect *arg1 = (wxRect *) 0 ;
6254 wxPoint *arg2 = 0 ;
6255 bool result;
6256 wxPoint temp2 ;
6257 PyObject * obj0 = 0 ;
6258 PyObject * obj1 = 0 ;
6259 char *kwnames[] = {
6260 (char *) "self",(char *) "pt", NULL
6261 };
6262
6263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6265 if (SWIG_arg_fail(1)) SWIG_fail;
6266 {
6267 arg2 = &temp2;
6268 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6269 }
6270 {
6271 PyThreadState* __tstate = wxPyBeginAllowThreads();
6272 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6273
6274 wxPyEndAllowThreads(__tstate);
6275 if (PyErr_Occurred()) SWIG_fail;
6276 }
6277 {
6278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6279 }
6280 return resultobj;
6281 fail:
6282 return NULL;
6283 }
6284
6285
6286 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6287 PyObject *resultobj = NULL;
6288 wxRect *arg1 = (wxRect *) 0 ;
6289 wxRect *arg2 = 0 ;
6290 bool result;
6291 wxRect temp2 ;
6292 PyObject * obj0 = 0 ;
6293 PyObject * obj1 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "self",(char *) "rect", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6300 if (SWIG_arg_fail(1)) SWIG_fail;
6301 {
6302 arg2 = &temp2;
6303 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6304 }
6305 {
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6308
6309 wxPyEndAllowThreads(__tstate);
6310 if (PyErr_Occurred()) SWIG_fail;
6311 }
6312 {
6313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6314 }
6315 return resultobj;
6316 fail:
6317 return NULL;
6318 }
6319
6320
6321 static PyObject *_wrap_Rect_CenterIn(PyObject *, PyObject *args, PyObject *kwargs) {
6322 PyObject *resultobj = NULL;
6323 wxRect *arg1 = (wxRect *) 0 ;
6324 wxRect *arg2 = 0 ;
6325 int arg3 = (int) wxBOTH ;
6326 wxRect result;
6327 wxRect temp2 ;
6328 PyObject * obj0 = 0 ;
6329 PyObject * obj1 = 0 ;
6330 PyObject * obj2 = 0 ;
6331 char *kwnames[] = {
6332 (char *) "self",(char *) "r",(char *) "dir", NULL
6333 };
6334
6335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) goto fail;
6336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6337 if (SWIG_arg_fail(1)) SWIG_fail;
6338 {
6339 arg2 = &temp2;
6340 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6341 }
6342 if (obj2) {
6343 {
6344 arg3 = static_cast<int >(SWIG_As_int(obj2));
6345 if (SWIG_arg_fail(3)) SWIG_fail;
6346 }
6347 }
6348 {
6349 PyThreadState* __tstate = wxPyBeginAllowThreads();
6350 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
6351
6352 wxPyEndAllowThreads(__tstate);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 {
6356 wxRect * resultptr;
6357 resultptr = new wxRect(static_cast<wxRect & >(result));
6358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6359 }
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj = NULL;
6368 wxRect *arg1 = (wxRect *) 0 ;
6369 int arg2 ;
6370 PyObject * obj0 = 0 ;
6371 PyObject * obj1 = 0 ;
6372 char *kwnames[] = {
6373 (char *) "self",(char *) "x", NULL
6374 };
6375
6376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6378 if (SWIG_arg_fail(1)) SWIG_fail;
6379 {
6380 arg2 = static_cast<int >(SWIG_As_int(obj1));
6381 if (SWIG_arg_fail(2)) SWIG_fail;
6382 }
6383 if (arg1) (arg1)->x = arg2;
6384
6385 Py_INCREF(Py_None); resultobj = Py_None;
6386 return resultobj;
6387 fail:
6388 return NULL;
6389 }
6390
6391
6392 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6393 PyObject *resultobj = NULL;
6394 wxRect *arg1 = (wxRect *) 0 ;
6395 int result;
6396 PyObject * obj0 = 0 ;
6397 char *kwnames[] = {
6398 (char *) "self", NULL
6399 };
6400
6401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6403 if (SWIG_arg_fail(1)) SWIG_fail;
6404 result = (int) ((arg1)->x);
6405
6406 {
6407 resultobj = SWIG_From_int(static_cast<int >(result));
6408 }
6409 return resultobj;
6410 fail:
6411 return NULL;
6412 }
6413
6414
6415 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6416 PyObject *resultobj = NULL;
6417 wxRect *arg1 = (wxRect *) 0 ;
6418 int arg2 ;
6419 PyObject * obj0 = 0 ;
6420 PyObject * obj1 = 0 ;
6421 char *kwnames[] = {
6422 (char *) "self",(char *) "y", NULL
6423 };
6424
6425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6427 if (SWIG_arg_fail(1)) SWIG_fail;
6428 {
6429 arg2 = static_cast<int >(SWIG_As_int(obj1));
6430 if (SWIG_arg_fail(2)) SWIG_fail;
6431 }
6432 if (arg1) (arg1)->y = arg2;
6433
6434 Py_INCREF(Py_None); resultobj = Py_None;
6435 return resultobj;
6436 fail:
6437 return NULL;
6438 }
6439
6440
6441 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6442 PyObject *resultobj = NULL;
6443 wxRect *arg1 = (wxRect *) 0 ;
6444 int result;
6445 PyObject * obj0 = 0 ;
6446 char *kwnames[] = {
6447 (char *) "self", NULL
6448 };
6449
6450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6452 if (SWIG_arg_fail(1)) SWIG_fail;
6453 result = (int) ((arg1)->y);
6454
6455 {
6456 resultobj = SWIG_From_int(static_cast<int >(result));
6457 }
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6465 PyObject *resultobj = NULL;
6466 wxRect *arg1 = (wxRect *) 0 ;
6467 int arg2 ;
6468 PyObject * obj0 = 0 ;
6469 PyObject * obj1 = 0 ;
6470 char *kwnames[] = {
6471 (char *) "self",(char *) "width", NULL
6472 };
6473
6474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6476 if (SWIG_arg_fail(1)) SWIG_fail;
6477 {
6478 arg2 = static_cast<int >(SWIG_As_int(obj1));
6479 if (SWIG_arg_fail(2)) SWIG_fail;
6480 }
6481 if (arg1) (arg1)->width = arg2;
6482
6483 Py_INCREF(Py_None); resultobj = Py_None;
6484 return resultobj;
6485 fail:
6486 return NULL;
6487 }
6488
6489
6490 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6491 PyObject *resultobj = NULL;
6492 wxRect *arg1 = (wxRect *) 0 ;
6493 int result;
6494 PyObject * obj0 = 0 ;
6495 char *kwnames[] = {
6496 (char *) "self", NULL
6497 };
6498
6499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6501 if (SWIG_arg_fail(1)) SWIG_fail;
6502 result = (int) ((arg1)->width);
6503
6504 {
6505 resultobj = SWIG_From_int(static_cast<int >(result));
6506 }
6507 return resultobj;
6508 fail:
6509 return NULL;
6510 }
6511
6512
6513 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6514 PyObject *resultobj = NULL;
6515 wxRect *arg1 = (wxRect *) 0 ;
6516 int arg2 ;
6517 PyObject * obj0 = 0 ;
6518 PyObject * obj1 = 0 ;
6519 char *kwnames[] = {
6520 (char *) "self",(char *) "height", NULL
6521 };
6522
6523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6525 if (SWIG_arg_fail(1)) SWIG_fail;
6526 {
6527 arg2 = static_cast<int >(SWIG_As_int(obj1));
6528 if (SWIG_arg_fail(2)) SWIG_fail;
6529 }
6530 if (arg1) (arg1)->height = arg2;
6531
6532 Py_INCREF(Py_None); resultobj = Py_None;
6533 return resultobj;
6534 fail:
6535 return NULL;
6536 }
6537
6538
6539 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6540 PyObject *resultobj = NULL;
6541 wxRect *arg1 = (wxRect *) 0 ;
6542 int result;
6543 PyObject * obj0 = 0 ;
6544 char *kwnames[] = {
6545 (char *) "self", NULL
6546 };
6547
6548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6550 if (SWIG_arg_fail(1)) SWIG_fail;
6551 result = (int) ((arg1)->height);
6552
6553 {
6554 resultobj = SWIG_From_int(static_cast<int >(result));
6555 }
6556 return resultobj;
6557 fail:
6558 return NULL;
6559 }
6560
6561
6562 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6563 PyObject *resultobj = NULL;
6564 wxRect *arg1 = (wxRect *) 0 ;
6565 int arg2 = (int) 0 ;
6566 int arg3 = (int) 0 ;
6567 int arg4 = (int) 0 ;
6568 int arg5 = (int) 0 ;
6569 PyObject * obj0 = 0 ;
6570 PyObject * obj1 = 0 ;
6571 PyObject * obj2 = 0 ;
6572 PyObject * obj3 = 0 ;
6573 PyObject * obj4 = 0 ;
6574 char *kwnames[] = {
6575 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6576 };
6577
6578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6580 if (SWIG_arg_fail(1)) SWIG_fail;
6581 if (obj1) {
6582 {
6583 arg2 = static_cast<int >(SWIG_As_int(obj1));
6584 if (SWIG_arg_fail(2)) SWIG_fail;
6585 }
6586 }
6587 if (obj2) {
6588 {
6589 arg3 = static_cast<int >(SWIG_As_int(obj2));
6590 if (SWIG_arg_fail(3)) SWIG_fail;
6591 }
6592 }
6593 if (obj3) {
6594 {
6595 arg4 = static_cast<int >(SWIG_As_int(obj3));
6596 if (SWIG_arg_fail(4)) SWIG_fail;
6597 }
6598 }
6599 if (obj4) {
6600 {
6601 arg5 = static_cast<int >(SWIG_As_int(obj4));
6602 if (SWIG_arg_fail(5)) SWIG_fail;
6603 }
6604 }
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6608
6609 wxPyEndAllowThreads(__tstate);
6610 if (PyErr_Occurred()) SWIG_fail;
6611 }
6612 Py_INCREF(Py_None); resultobj = Py_None;
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj = NULL;
6621 wxRect *arg1 = (wxRect *) 0 ;
6622 PyObject *result;
6623 PyObject * obj0 = 0 ;
6624 char *kwnames[] = {
6625 (char *) "self", NULL
6626 };
6627
6628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6630 if (SWIG_arg_fail(1)) SWIG_fail;
6631 {
6632 PyThreadState* __tstate = wxPyBeginAllowThreads();
6633 result = (PyObject *)wxRect_Get(arg1);
6634
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 resultobj = result;
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6646 PyObject *obj;
6647 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6648 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6649 Py_INCREF(obj);
6650 return Py_BuildValue((char *)"");
6651 }
6652 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6653 PyObject *resultobj = NULL;
6654 wxRect *arg1 = (wxRect *) 0 ;
6655 wxRect *arg2 = (wxRect *) 0 ;
6656 PyObject *result;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char *kwnames[] = {
6660 (char *) "r1",(char *) "r2", NULL
6661 };
6662
6663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6665 if (SWIG_arg_fail(1)) SWIG_fail;
6666 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6667 if (SWIG_arg_fail(2)) SWIG_fail;
6668 {
6669 if (!wxPyCheckForApp()) SWIG_fail;
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 result = (PyObject *)wxIntersectRect(arg1,arg2);
6672
6673 wxPyEndAllowThreads(__tstate);
6674 if (PyErr_Occurred()) SWIG_fail;
6675 }
6676 resultobj = result;
6677 return resultobj;
6678 fail:
6679 return NULL;
6680 }
6681
6682
6683 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6684 PyObject *resultobj = NULL;
6685 double arg1 = (double) 0.0 ;
6686 double arg2 = (double) 0.0 ;
6687 wxPoint2D *result;
6688 PyObject * obj0 = 0 ;
6689 PyObject * obj1 = 0 ;
6690 char *kwnames[] = {
6691 (char *) "x",(char *) "y", NULL
6692 };
6693
6694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6695 if (obj0) {
6696 {
6697 arg1 = static_cast<double >(SWIG_As_double(obj0));
6698 if (SWIG_arg_fail(1)) SWIG_fail;
6699 }
6700 }
6701 if (obj1) {
6702 {
6703 arg2 = static_cast<double >(SWIG_As_double(obj1));
6704 if (SWIG_arg_fail(2)) SWIG_fail;
6705 }
6706 }
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6715 return resultobj;
6716 fail:
6717 return NULL;
6718 }
6719
6720
6721 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6722 PyObject *resultobj = NULL;
6723 wxPoint2D *arg1 = 0 ;
6724 wxPoint2D *result;
6725 wxPoint2D temp1 ;
6726 PyObject * obj0 = 0 ;
6727 char *kwnames[] = {
6728 (char *) "pt", NULL
6729 };
6730
6731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6732 {
6733 arg1 = &temp1;
6734 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6735 }
6736 {
6737 PyThreadState* __tstate = wxPyBeginAllowThreads();
6738 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6739
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6751 PyObject *resultobj = NULL;
6752 wxPoint *arg1 = 0 ;
6753 wxPoint2D *result;
6754 wxPoint temp1 ;
6755 PyObject * obj0 = 0 ;
6756 char *kwnames[] = {
6757 (char *) "pt", NULL
6758 };
6759
6760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6761 {
6762 arg1 = &temp1;
6763 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6764 }
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6780 PyObject *resultobj = NULL;
6781 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6782 int *arg2 = (int *) 0 ;
6783 int *arg3 = (int *) 0 ;
6784 int temp2 ;
6785 int res2 = 0 ;
6786 int temp3 ;
6787 int res3 = 0 ;
6788 PyObject * obj0 = 0 ;
6789 char *kwnames[] = {
6790 (char *) "self", NULL
6791 };
6792
6793 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6794 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6797 if (SWIG_arg_fail(1)) SWIG_fail;
6798 {
6799 PyThreadState* __tstate = wxPyBeginAllowThreads();
6800 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6801
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 Py_INCREF(Py_None); resultobj = Py_None;
6806 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6807 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6808 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6809 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6810 return resultobj;
6811 fail:
6812 return NULL;
6813 }
6814
6815
6816 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6817 PyObject *resultobj = NULL;
6818 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6819 int *arg2 = (int *) 0 ;
6820 int *arg3 = (int *) 0 ;
6821 int temp2 ;
6822 int res2 = 0 ;
6823 int temp3 ;
6824 int res3 = 0 ;
6825 PyObject * obj0 = 0 ;
6826 char *kwnames[] = {
6827 (char *) "self", NULL
6828 };
6829
6830 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6831 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6838
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 Py_INCREF(Py_None); resultobj = Py_None;
6843 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6844 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6845 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6846 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6854 PyObject *resultobj = NULL;
6855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6856 double result;
6857 PyObject * obj0 = 0 ;
6858 char *kwnames[] = {
6859 (char *) "self", NULL
6860 };
6861
6862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6864 if (SWIG_arg_fail(1)) SWIG_fail;
6865 {
6866 PyThreadState* __tstate = wxPyBeginAllowThreads();
6867 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6868
6869 wxPyEndAllowThreads(__tstate);
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 {
6873 resultobj = SWIG_From_double(static_cast<double >(result));
6874 }
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6882 PyObject *resultobj = NULL;
6883 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6884 double result;
6885 PyObject * obj0 = 0 ;
6886 char *kwnames[] = {
6887 (char *) "self", NULL
6888 };
6889
6890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6892 if (SWIG_arg_fail(1)) SWIG_fail;
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6896
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 {
6901 resultobj = SWIG_From_double(static_cast<double >(result));
6902 }
6903 return resultobj;
6904 fail:
6905 return NULL;
6906 }
6907
6908
6909 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6910 PyObject *resultobj = NULL;
6911 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6912 double arg2 ;
6913 PyObject * obj0 = 0 ;
6914 PyObject * obj1 = 0 ;
6915 char *kwnames[] = {
6916 (char *) "self",(char *) "length", NULL
6917 };
6918
6919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6921 if (SWIG_arg_fail(1)) SWIG_fail;
6922 {
6923 arg2 = static_cast<double >(SWIG_As_double(obj1));
6924 if (SWIG_arg_fail(2)) SWIG_fail;
6925 }
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 (arg1)->SetVectorLength(arg2);
6929
6930 wxPyEndAllowThreads(__tstate);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 Py_INCREF(Py_None); resultobj = Py_None;
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6941 PyObject *resultobj = NULL;
6942 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6943 double arg2 ;
6944 PyObject * obj0 = 0 ;
6945 PyObject * obj1 = 0 ;
6946 char *kwnames[] = {
6947 (char *) "self",(char *) "degrees", NULL
6948 };
6949
6950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6952 if (SWIG_arg_fail(1)) SWIG_fail;
6953 {
6954 arg2 = static_cast<double >(SWIG_As_double(obj1));
6955 if (SWIG_arg_fail(2)) SWIG_fail;
6956 }
6957 {
6958 PyThreadState* __tstate = wxPyBeginAllowThreads();
6959 (arg1)->SetVectorAngle(arg2);
6960
6961 wxPyEndAllowThreads(__tstate);
6962 if (PyErr_Occurred()) SWIG_fail;
6963 }
6964 Py_INCREF(Py_None); resultobj = Py_None;
6965 return resultobj;
6966 fail:
6967 return NULL;
6968 }
6969
6970
6971 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6972 PyObject *resultobj = NULL;
6973 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6974 wxPoint2D *arg2 = 0 ;
6975 double result;
6976 wxPoint2D temp2 ;
6977 PyObject * obj0 = 0 ;
6978 PyObject * obj1 = 0 ;
6979 char *kwnames[] = {
6980 (char *) "self",(char *) "pt", NULL
6981 };
6982
6983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6985 if (SWIG_arg_fail(1)) SWIG_fail;
6986 {
6987 arg2 = &temp2;
6988 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6989 }
6990 {
6991 PyThreadState* __tstate = wxPyBeginAllowThreads();
6992 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6993
6994 wxPyEndAllowThreads(__tstate);
6995 if (PyErr_Occurred()) SWIG_fail;
6996 }
6997 {
6998 resultobj = SWIG_From_double(static_cast<double >(result));
6999 }
7000 return resultobj;
7001 fail:
7002 return NULL;
7003 }
7004
7005
7006 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
7007 PyObject *resultobj = NULL;
7008 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7009 wxPoint2D *arg2 = 0 ;
7010 double result;
7011 wxPoint2D temp2 ;
7012 PyObject * obj0 = 0 ;
7013 PyObject * obj1 = 0 ;
7014 char *kwnames[] = {
7015 (char *) "self",(char *) "pt", NULL
7016 };
7017
7018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
7019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7020 if (SWIG_arg_fail(1)) SWIG_fail;
7021 {
7022 arg2 = &temp2;
7023 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7024 }
7025 {
7026 PyThreadState* __tstate = wxPyBeginAllowThreads();
7027 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
7028
7029 wxPyEndAllowThreads(__tstate);
7030 if (PyErr_Occurred()) SWIG_fail;
7031 }
7032 {
7033 resultobj = SWIG_From_double(static_cast<double >(result));
7034 }
7035 return resultobj;
7036 fail:
7037 return NULL;
7038 }
7039
7040
7041 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7042 PyObject *resultobj = NULL;
7043 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7044 wxPoint2D *arg2 = 0 ;
7045 double result;
7046 wxPoint2D temp2 ;
7047 PyObject * obj0 = 0 ;
7048 PyObject * obj1 = 0 ;
7049 char *kwnames[] = {
7050 (char *) "self",(char *) "vec", NULL
7051 };
7052
7053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
7054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7055 if (SWIG_arg_fail(1)) SWIG_fail;
7056 {
7057 arg2 = &temp2;
7058 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7059 }
7060 {
7061 PyThreadState* __tstate = wxPyBeginAllowThreads();
7062 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7063
7064 wxPyEndAllowThreads(__tstate);
7065 if (PyErr_Occurred()) SWIG_fail;
7066 }
7067 {
7068 resultobj = SWIG_From_double(static_cast<double >(result));
7069 }
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7077 PyObject *resultobj = NULL;
7078 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7079 wxPoint2D *arg2 = 0 ;
7080 double result;
7081 wxPoint2D temp2 ;
7082 PyObject * obj0 = 0 ;
7083 PyObject * obj1 = 0 ;
7084 char *kwnames[] = {
7085 (char *) "self",(char *) "vec", NULL
7086 };
7087
7088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7090 if (SWIG_arg_fail(1)) SWIG_fail;
7091 {
7092 arg2 = &temp2;
7093 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7094 }
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7098
7099 wxPyEndAllowThreads(__tstate);
7100 if (PyErr_Occurred()) SWIG_fail;
7101 }
7102 {
7103 resultobj = SWIG_From_double(static_cast<double >(result));
7104 }
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7112 PyObject *resultobj = NULL;
7113 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7114 wxPoint2D result;
7115 PyObject * obj0 = 0 ;
7116 char *kwnames[] = {
7117 (char *) "self", NULL
7118 };
7119
7120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
7121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7122 if (SWIG_arg_fail(1)) SWIG_fail;
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (arg1)->operator -();
7126
7127 wxPyEndAllowThreads(__tstate);
7128 if (PyErr_Occurred()) SWIG_fail;
7129 }
7130 {
7131 wxPoint2D * resultptr;
7132 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7133 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7134 }
7135 return resultobj;
7136 fail:
7137 return NULL;
7138 }
7139
7140
7141 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7142 PyObject *resultobj = NULL;
7143 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7144 wxPoint2D *arg2 = 0 ;
7145 wxPoint2D *result;
7146 wxPoint2D temp2 ;
7147 PyObject * obj0 = 0 ;
7148 PyObject * obj1 = 0 ;
7149 char *kwnames[] = {
7150 (char *) "self",(char *) "pt", NULL
7151 };
7152
7153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7155 if (SWIG_arg_fail(1)) SWIG_fail;
7156 {
7157 arg2 = &temp2;
7158 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7159 }
7160 {
7161 PyThreadState* __tstate = wxPyBeginAllowThreads();
7162 {
7163 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7164 result = (wxPoint2D *) &_result_ref;
7165 }
7166
7167 wxPyEndAllowThreads(__tstate);
7168 if (PyErr_Occurred()) SWIG_fail;
7169 }
7170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7171 return resultobj;
7172 fail:
7173 return NULL;
7174 }
7175
7176
7177 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7178 PyObject *resultobj = NULL;
7179 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7180 wxPoint2D *arg2 = 0 ;
7181 wxPoint2D *result;
7182 wxPoint2D temp2 ;
7183 PyObject * obj0 = 0 ;
7184 PyObject * obj1 = 0 ;
7185 char *kwnames[] = {
7186 (char *) "self",(char *) "pt", NULL
7187 };
7188
7189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7191 if (SWIG_arg_fail(1)) SWIG_fail;
7192 {
7193 arg2 = &temp2;
7194 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7195 }
7196 {
7197 PyThreadState* __tstate = wxPyBeginAllowThreads();
7198 {
7199 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7200 result = (wxPoint2D *) &_result_ref;
7201 }
7202
7203 wxPyEndAllowThreads(__tstate);
7204 if (PyErr_Occurred()) SWIG_fail;
7205 }
7206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7207 return resultobj;
7208 fail:
7209 return NULL;
7210 }
7211
7212
7213 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7214 PyObject *resultobj = NULL;
7215 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7216 wxPoint2D *arg2 = 0 ;
7217 wxPoint2D *result;
7218 wxPoint2D temp2 ;
7219 PyObject * obj0 = 0 ;
7220 PyObject * obj1 = 0 ;
7221 char *kwnames[] = {
7222 (char *) "self",(char *) "pt", NULL
7223 };
7224
7225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7227 if (SWIG_arg_fail(1)) SWIG_fail;
7228 {
7229 arg2 = &temp2;
7230 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7231 }
7232 {
7233 PyThreadState* __tstate = wxPyBeginAllowThreads();
7234 {
7235 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7236 result = (wxPoint2D *) &_result_ref;
7237 }
7238
7239 wxPyEndAllowThreads(__tstate);
7240 if (PyErr_Occurred()) SWIG_fail;
7241 }
7242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7243 return resultobj;
7244 fail:
7245 return NULL;
7246 }
7247
7248
7249 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7250 PyObject *resultobj = NULL;
7251 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7252 wxPoint2D *arg2 = 0 ;
7253 wxPoint2D *result;
7254 wxPoint2D temp2 ;
7255 PyObject * obj0 = 0 ;
7256 PyObject * obj1 = 0 ;
7257 char *kwnames[] = {
7258 (char *) "self",(char *) "pt", NULL
7259 };
7260
7261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7263 if (SWIG_arg_fail(1)) SWIG_fail;
7264 {
7265 arg2 = &temp2;
7266 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7267 }
7268 {
7269 PyThreadState* __tstate = wxPyBeginAllowThreads();
7270 {
7271 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7272 result = (wxPoint2D *) &_result_ref;
7273 }
7274
7275 wxPyEndAllowThreads(__tstate);
7276 if (PyErr_Occurred()) SWIG_fail;
7277 }
7278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7279 return resultobj;
7280 fail:
7281 return NULL;
7282 }
7283
7284
7285 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7286 PyObject *resultobj = NULL;
7287 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7288 wxPoint2D *arg2 = 0 ;
7289 bool result;
7290 wxPoint2D temp2 ;
7291 PyObject * obj0 = 0 ;
7292 PyObject * obj1 = 0 ;
7293 char *kwnames[] = {
7294 (char *) "self",(char *) "pt", NULL
7295 };
7296
7297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7299 if (SWIG_arg_fail(1)) SWIG_fail;
7300 {
7301 arg2 = &temp2;
7302 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7303 }
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = NULL;
7322 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7323 wxPoint2D *arg2 = 0 ;
7324 bool result;
7325 wxPoint2D temp2 ;
7326 PyObject * obj0 = 0 ;
7327 PyObject * obj1 = 0 ;
7328 char *kwnames[] = {
7329 (char *) "self",(char *) "pt", NULL
7330 };
7331
7332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7334 if (SWIG_arg_fail(1)) SWIG_fail;
7335 {
7336 arg2 = &temp2;
7337 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7338 }
7339 {
7340 PyThreadState* __tstate = wxPyBeginAllowThreads();
7341 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7342
7343 wxPyEndAllowThreads(__tstate);
7344 if (PyErr_Occurred()) SWIG_fail;
7345 }
7346 {
7347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7348 }
7349 return resultobj;
7350 fail:
7351 return NULL;
7352 }
7353
7354
7355 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7356 PyObject *resultobj = NULL;
7357 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7358 double arg2 ;
7359 PyObject * obj0 = 0 ;
7360 PyObject * obj1 = 0 ;
7361 char *kwnames[] = {
7362 (char *) "self",(char *) "m_x", NULL
7363 };
7364
7365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7367 if (SWIG_arg_fail(1)) SWIG_fail;
7368 {
7369 arg2 = static_cast<double >(SWIG_As_double(obj1));
7370 if (SWIG_arg_fail(2)) SWIG_fail;
7371 }
7372 if (arg1) (arg1)->m_x = arg2;
7373
7374 Py_INCREF(Py_None); resultobj = Py_None;
7375 return resultobj;
7376 fail:
7377 return NULL;
7378 }
7379
7380
7381 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7382 PyObject *resultobj = NULL;
7383 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7384 double result;
7385 PyObject * obj0 = 0 ;
7386 char *kwnames[] = {
7387 (char *) "self", NULL
7388 };
7389
7390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7392 if (SWIG_arg_fail(1)) SWIG_fail;
7393 result = (double) ((arg1)->m_x);
7394
7395 {
7396 resultobj = SWIG_From_double(static_cast<double >(result));
7397 }
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7405 PyObject *resultobj = NULL;
7406 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7407 double arg2 ;
7408 PyObject * obj0 = 0 ;
7409 PyObject * obj1 = 0 ;
7410 char *kwnames[] = {
7411 (char *) "self",(char *) "m_y", NULL
7412 };
7413
7414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7416 if (SWIG_arg_fail(1)) SWIG_fail;
7417 {
7418 arg2 = static_cast<double >(SWIG_As_double(obj1));
7419 if (SWIG_arg_fail(2)) SWIG_fail;
7420 }
7421 if (arg1) (arg1)->m_y = arg2;
7422
7423 Py_INCREF(Py_None); resultobj = Py_None;
7424 return resultobj;
7425 fail:
7426 return NULL;
7427 }
7428
7429
7430 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7431 PyObject *resultobj = NULL;
7432 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7433 double result;
7434 PyObject * obj0 = 0 ;
7435 char *kwnames[] = {
7436 (char *) "self", NULL
7437 };
7438
7439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7441 if (SWIG_arg_fail(1)) SWIG_fail;
7442 result = (double) ((arg1)->m_y);
7443
7444 {
7445 resultobj = SWIG_From_double(static_cast<double >(result));
7446 }
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj = NULL;
7455 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7456 double arg2 = (double) 0 ;
7457 double arg3 = (double) 0 ;
7458 PyObject * obj0 = 0 ;
7459 PyObject * obj1 = 0 ;
7460 PyObject * obj2 = 0 ;
7461 char *kwnames[] = {
7462 (char *) "self",(char *) "x",(char *) "y", NULL
7463 };
7464
7465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7467 if (SWIG_arg_fail(1)) SWIG_fail;
7468 if (obj1) {
7469 {
7470 arg2 = static_cast<double >(SWIG_As_double(obj1));
7471 if (SWIG_arg_fail(2)) SWIG_fail;
7472 }
7473 }
7474 if (obj2) {
7475 {
7476 arg3 = static_cast<double >(SWIG_As_double(obj2));
7477 if (SWIG_arg_fail(3)) SWIG_fail;
7478 }
7479 }
7480 {
7481 PyThreadState* __tstate = wxPyBeginAllowThreads();
7482 wxPoint2D_Set(arg1,arg2,arg3);
7483
7484 wxPyEndAllowThreads(__tstate);
7485 if (PyErr_Occurred()) SWIG_fail;
7486 }
7487 Py_INCREF(Py_None); resultobj = Py_None;
7488 return resultobj;
7489 fail:
7490 return NULL;
7491 }
7492
7493
7494 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7495 PyObject *resultobj = NULL;
7496 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7497 PyObject *result;
7498 PyObject * obj0 = 0 ;
7499 char *kwnames[] = {
7500 (char *) "self", NULL
7501 };
7502
7503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7505 if (SWIG_arg_fail(1)) SWIG_fail;
7506 {
7507 PyThreadState* __tstate = wxPyBeginAllowThreads();
7508 result = (PyObject *)wxPoint2D_Get(arg1);
7509
7510 wxPyEndAllowThreads(__tstate);
7511 if (PyErr_Occurred()) SWIG_fail;
7512 }
7513 resultobj = result;
7514 return resultobj;
7515 fail:
7516 return NULL;
7517 }
7518
7519
7520 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7521 PyObject *obj;
7522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7523 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7524 Py_INCREF(obj);
7525 return Py_BuildValue((char *)"");
7526 }
7527 static int _wrap_DefaultPosition_set(PyObject *) {
7528 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7529 return 1;
7530 }
7531
7532
7533 static PyObject *_wrap_DefaultPosition_get(void) {
7534 PyObject *pyobj = NULL;
7535
7536 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7537 return pyobj;
7538 }
7539
7540
7541 static int _wrap_DefaultSize_set(PyObject *) {
7542 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7543 return 1;
7544 }
7545
7546
7547 static PyObject *_wrap_DefaultSize_get(void) {
7548 PyObject *pyobj = NULL;
7549
7550 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7551 return pyobj;
7552 }
7553
7554
7555 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7556 PyObject *resultobj = NULL;
7557 PyObject *arg1 = (PyObject *) 0 ;
7558 wxPyInputStream *result;
7559 PyObject * obj0 = 0 ;
7560 char *kwnames[] = {
7561 (char *) "p", NULL
7562 };
7563
7564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7565 arg1 = obj0;
7566 {
7567 PyThreadState* __tstate = wxPyBeginAllowThreads();
7568 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7569
7570 wxPyEndAllowThreads(__tstate);
7571 if (PyErr_Occurred()) SWIG_fail;
7572 }
7573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7574 return resultobj;
7575 fail:
7576 return NULL;
7577 }
7578
7579
7580 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7581 PyObject *resultobj = NULL;
7582 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7583 PyObject * obj0 = 0 ;
7584 char *kwnames[] = {
7585 (char *) "self", NULL
7586 };
7587
7588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7590 if (SWIG_arg_fail(1)) SWIG_fail;
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 delete arg1;
7594
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 Py_INCREF(Py_None); resultobj = Py_None;
7599 return resultobj;
7600 fail:
7601 return NULL;
7602 }
7603
7604
7605 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7606 PyObject *resultobj = NULL;
7607 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7608 PyObject * obj0 = 0 ;
7609 char *kwnames[] = {
7610 (char *) "self", NULL
7611 };
7612
7613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7615 if (SWIG_arg_fail(1)) SWIG_fail;
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 (arg1)->close();
7619
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 Py_INCREF(Py_None); resultobj = Py_None;
7624 return resultobj;
7625 fail:
7626 return NULL;
7627 }
7628
7629
7630 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7631 PyObject *resultobj = NULL;
7632 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7633 PyObject * obj0 = 0 ;
7634 char *kwnames[] = {
7635 (char *) "self", NULL
7636 };
7637
7638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7640 if (SWIG_arg_fail(1)) SWIG_fail;
7641 {
7642 PyThreadState* __tstate = wxPyBeginAllowThreads();
7643 (arg1)->flush();
7644
7645 wxPyEndAllowThreads(__tstate);
7646 if (PyErr_Occurred()) SWIG_fail;
7647 }
7648 Py_INCREF(Py_None); resultobj = Py_None;
7649 return resultobj;
7650 fail:
7651 return NULL;
7652 }
7653
7654
7655 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7656 PyObject *resultobj = NULL;
7657 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7658 bool result;
7659 PyObject * obj0 = 0 ;
7660 char *kwnames[] = {
7661 (char *) "self", NULL
7662 };
7663
7664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7666 if (SWIG_arg_fail(1)) SWIG_fail;
7667 {
7668 PyThreadState* __tstate = wxPyBeginAllowThreads();
7669 result = (bool)(arg1)->eof();
7670
7671 wxPyEndAllowThreads(__tstate);
7672 if (PyErr_Occurred()) SWIG_fail;
7673 }
7674 {
7675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7676 }
7677 return resultobj;
7678 fail:
7679 return NULL;
7680 }
7681
7682
7683 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7684 PyObject *resultobj = NULL;
7685 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7686 int arg2 = (int) -1 ;
7687 PyObject *result;
7688 PyObject * obj0 = 0 ;
7689 PyObject * obj1 = 0 ;
7690 char *kwnames[] = {
7691 (char *) "self",(char *) "size", NULL
7692 };
7693
7694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7696 if (SWIG_arg_fail(1)) SWIG_fail;
7697 if (obj1) {
7698 {
7699 arg2 = static_cast<int >(SWIG_As_int(obj1));
7700 if (SWIG_arg_fail(2)) SWIG_fail;
7701 }
7702 }
7703 {
7704 PyThreadState* __tstate = wxPyBeginAllowThreads();
7705 result = (PyObject *)(arg1)->read(arg2);
7706
7707 wxPyEndAllowThreads(__tstate);
7708 if (PyErr_Occurred()) SWIG_fail;
7709 }
7710 resultobj = result;
7711 return resultobj;
7712 fail:
7713 return NULL;
7714 }
7715
7716
7717 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7718 PyObject *resultobj = NULL;
7719 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7720 int arg2 = (int) -1 ;
7721 PyObject *result;
7722 PyObject * obj0 = 0 ;
7723 PyObject * obj1 = 0 ;
7724 char *kwnames[] = {
7725 (char *) "self",(char *) "size", NULL
7726 };
7727
7728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7730 if (SWIG_arg_fail(1)) SWIG_fail;
7731 if (obj1) {
7732 {
7733 arg2 = static_cast<int >(SWIG_As_int(obj1));
7734 if (SWIG_arg_fail(2)) SWIG_fail;
7735 }
7736 }
7737 {
7738 PyThreadState* __tstate = wxPyBeginAllowThreads();
7739 result = (PyObject *)(arg1)->readline(arg2);
7740
7741 wxPyEndAllowThreads(__tstate);
7742 if (PyErr_Occurred()) SWIG_fail;
7743 }
7744 resultobj = result;
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7752 PyObject *resultobj = NULL;
7753 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7754 int arg2 = (int) -1 ;
7755 PyObject *result;
7756 PyObject * obj0 = 0 ;
7757 PyObject * obj1 = 0 ;
7758 char *kwnames[] = {
7759 (char *) "self",(char *) "sizehint", NULL
7760 };
7761
7762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7764 if (SWIG_arg_fail(1)) SWIG_fail;
7765 if (obj1) {
7766 {
7767 arg2 = static_cast<int >(SWIG_As_int(obj1));
7768 if (SWIG_arg_fail(2)) SWIG_fail;
7769 }
7770 }
7771 {
7772 PyThreadState* __tstate = wxPyBeginAllowThreads();
7773 result = (PyObject *)(arg1)->readlines(arg2);
7774
7775 wxPyEndAllowThreads(__tstate);
7776 if (PyErr_Occurred()) SWIG_fail;
7777 }
7778 resultobj = result;
7779 return resultobj;
7780 fail:
7781 return NULL;
7782 }
7783
7784
7785 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7786 PyObject *resultobj = NULL;
7787 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7788 int arg2 ;
7789 int arg3 = (int) 0 ;
7790 PyObject * obj0 = 0 ;
7791 PyObject * obj1 = 0 ;
7792 PyObject * obj2 = 0 ;
7793 char *kwnames[] = {
7794 (char *) "self",(char *) "offset",(char *) "whence", NULL
7795 };
7796
7797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7799 if (SWIG_arg_fail(1)) SWIG_fail;
7800 {
7801 arg2 = static_cast<int >(SWIG_As_int(obj1));
7802 if (SWIG_arg_fail(2)) SWIG_fail;
7803 }
7804 if (obj2) {
7805 {
7806 arg3 = static_cast<int >(SWIG_As_int(obj2));
7807 if (SWIG_arg_fail(3)) SWIG_fail;
7808 }
7809 }
7810 {
7811 PyThreadState* __tstate = wxPyBeginAllowThreads();
7812 (arg1)->seek(arg2,arg3);
7813
7814 wxPyEndAllowThreads(__tstate);
7815 if (PyErr_Occurred()) SWIG_fail;
7816 }
7817 Py_INCREF(Py_None); resultobj = Py_None;
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj = NULL;
7826 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7827 int result;
7828 PyObject * obj0 = 0 ;
7829 char *kwnames[] = {
7830 (char *) "self", NULL
7831 };
7832
7833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7835 if (SWIG_arg_fail(1)) SWIG_fail;
7836 {
7837 PyThreadState* __tstate = wxPyBeginAllowThreads();
7838 result = (int)(arg1)->tell();
7839
7840 wxPyEndAllowThreads(__tstate);
7841 if (PyErr_Occurred()) SWIG_fail;
7842 }
7843 {
7844 resultobj = SWIG_From_int(static_cast<int >(result));
7845 }
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7853 PyObject *resultobj = NULL;
7854 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7855 char result;
7856 PyObject * obj0 = 0 ;
7857 char *kwnames[] = {
7858 (char *) "self", NULL
7859 };
7860
7861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7863 if (SWIG_arg_fail(1)) SWIG_fail;
7864 {
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 result = (char)(arg1)->Peek();
7867
7868 wxPyEndAllowThreads(__tstate);
7869 if (PyErr_Occurred()) SWIG_fail;
7870 }
7871 {
7872 resultobj = SWIG_From_char(static_cast<char >(result));
7873 }
7874 return resultobj;
7875 fail:
7876 return NULL;
7877 }
7878
7879
7880 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7881 PyObject *resultobj = NULL;
7882 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7883 char result;
7884 PyObject * obj0 = 0 ;
7885 char *kwnames[] = {
7886 (char *) "self", NULL
7887 };
7888
7889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7891 if (SWIG_arg_fail(1)) SWIG_fail;
7892 {
7893 PyThreadState* __tstate = wxPyBeginAllowThreads();
7894 result = (char)(arg1)->GetC();
7895
7896 wxPyEndAllowThreads(__tstate);
7897 if (PyErr_Occurred()) SWIG_fail;
7898 }
7899 {
7900 resultobj = SWIG_From_char(static_cast<char >(result));
7901 }
7902 return resultobj;
7903 fail:
7904 return NULL;
7905 }
7906
7907
7908 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7909 PyObject *resultobj = NULL;
7910 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7911 size_t result;
7912 PyObject * obj0 = 0 ;
7913 char *kwnames[] = {
7914 (char *) "self", NULL
7915 };
7916
7917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7919 if (SWIG_arg_fail(1)) SWIG_fail;
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 result = (size_t)(arg1)->LastRead();
7923
7924 wxPyEndAllowThreads(__tstate);
7925 if (PyErr_Occurred()) SWIG_fail;
7926 }
7927 {
7928 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7929 }
7930 return resultobj;
7931 fail:
7932 return NULL;
7933 }
7934
7935
7936 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj = NULL;
7938 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7939 bool result;
7940 PyObject * obj0 = 0 ;
7941 char *kwnames[] = {
7942 (char *) "self", NULL
7943 };
7944
7945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7947 if (SWIG_arg_fail(1)) SWIG_fail;
7948 {
7949 PyThreadState* __tstate = wxPyBeginAllowThreads();
7950 result = (bool)(arg1)->CanRead();
7951
7952 wxPyEndAllowThreads(__tstate);
7953 if (PyErr_Occurred()) SWIG_fail;
7954 }
7955 {
7956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7957 }
7958 return resultobj;
7959 fail:
7960 return NULL;
7961 }
7962
7963
7964 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7965 PyObject *resultobj = NULL;
7966 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7967 bool result;
7968 PyObject * obj0 = 0 ;
7969 char *kwnames[] = {
7970 (char *) "self", NULL
7971 };
7972
7973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7975 if (SWIG_arg_fail(1)) SWIG_fail;
7976 {
7977 PyThreadState* __tstate = wxPyBeginAllowThreads();
7978 result = (bool)(arg1)->Eof();
7979
7980 wxPyEndAllowThreads(__tstate);
7981 if (PyErr_Occurred()) SWIG_fail;
7982 }
7983 {
7984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7985 }
7986 return resultobj;
7987 fail:
7988 return NULL;
7989 }
7990
7991
7992 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7993 PyObject *resultobj = NULL;
7994 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7995 char arg2 ;
7996 bool result;
7997 PyObject * obj0 = 0 ;
7998 PyObject * obj1 = 0 ;
7999 char *kwnames[] = {
8000 (char *) "self",(char *) "c", NULL
8001 };
8002
8003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
8004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8005 if (SWIG_arg_fail(1)) SWIG_fail;
8006 {
8007 arg2 = static_cast<char >(SWIG_As_char(obj1));
8008 if (SWIG_arg_fail(2)) SWIG_fail;
8009 }
8010 {
8011 PyThreadState* __tstate = wxPyBeginAllowThreads();
8012 result = (bool)(arg1)->Ungetch(arg2);
8013
8014 wxPyEndAllowThreads(__tstate);
8015 if (PyErr_Occurred()) SWIG_fail;
8016 }
8017 {
8018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8019 }
8020 return resultobj;
8021 fail:
8022 return NULL;
8023 }
8024
8025
8026 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
8027 PyObject *resultobj = NULL;
8028 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8029 long arg2 ;
8030 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
8031 long result;
8032 PyObject * obj0 = 0 ;
8033 PyObject * obj1 = 0 ;
8034 PyObject * obj2 = 0 ;
8035 char *kwnames[] = {
8036 (char *) "self",(char *) "pos",(char *) "mode", NULL
8037 };
8038
8039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
8040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8041 if (SWIG_arg_fail(1)) SWIG_fail;
8042 {
8043 arg2 = static_cast<long >(SWIG_As_long(obj1));
8044 if (SWIG_arg_fail(2)) SWIG_fail;
8045 }
8046 if (obj2) {
8047 {
8048 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
8049 if (SWIG_arg_fail(3)) SWIG_fail;
8050 }
8051 }
8052 {
8053 PyThreadState* __tstate = wxPyBeginAllowThreads();
8054 result = (long)(arg1)->SeekI(arg2,arg3);
8055
8056 wxPyEndAllowThreads(__tstate);
8057 if (PyErr_Occurred()) SWIG_fail;
8058 }
8059 {
8060 resultobj = SWIG_From_long(static_cast<long >(result));
8061 }
8062 return resultobj;
8063 fail:
8064 return NULL;
8065 }
8066
8067
8068 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8069 PyObject *resultobj = NULL;
8070 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8071 long result;
8072 PyObject * obj0 = 0 ;
8073 char *kwnames[] = {
8074 (char *) "self", NULL
8075 };
8076
8077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8079 if (SWIG_arg_fail(1)) SWIG_fail;
8080 {
8081 PyThreadState* __tstate = wxPyBeginAllowThreads();
8082 result = (long)(arg1)->TellI();
8083
8084 wxPyEndAllowThreads(__tstate);
8085 if (PyErr_Occurred()) SWIG_fail;
8086 }
8087 {
8088 resultobj = SWIG_From_long(static_cast<long >(result));
8089 }
8090 return resultobj;
8091 fail:
8092 return NULL;
8093 }
8094
8095
8096 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8097 PyObject *obj;
8098 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8099 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8100 Py_INCREF(obj);
8101 return Py_BuildValue((char *)"");
8102 }
8103 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8104 PyObject *resultobj = NULL;
8105 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8106 PyObject *arg2 = (PyObject *) 0 ;
8107 PyObject * obj0 = 0 ;
8108 PyObject * obj1 = 0 ;
8109 char *kwnames[] = {
8110 (char *) "self",(char *) "obj", NULL
8111 };
8112
8113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8115 if (SWIG_arg_fail(1)) SWIG_fail;
8116 arg2 = obj1;
8117 {
8118 PyThreadState* __tstate = wxPyBeginAllowThreads();
8119 wxOutputStream_write(arg1,arg2);
8120
8121 wxPyEndAllowThreads(__tstate);
8122 if (PyErr_Occurred()) SWIG_fail;
8123 }
8124 Py_INCREF(Py_None); resultobj = Py_None;
8125 return resultobj;
8126 fail:
8127 return NULL;
8128 }
8129
8130
8131 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8132 PyObject *obj;
8133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8134 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8135 Py_INCREF(obj);
8136 return Py_BuildValue((char *)"");
8137 }
8138 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8139 PyObject *resultobj = NULL;
8140 wxInputStream *arg1 = (wxInputStream *) 0 ;
8141 wxString *arg2 = 0 ;
8142 wxString *arg3 = 0 ;
8143 wxString *arg4 = 0 ;
8144 wxDateTime arg5 ;
8145 wxFSFile *result;
8146 wxPyInputStream *temp1 ;
8147 bool temp2 = false ;
8148 bool temp3 = false ;
8149 bool temp4 = false ;
8150 PyObject * obj0 = 0 ;
8151 PyObject * obj1 = 0 ;
8152 PyObject * obj2 = 0 ;
8153 PyObject * obj3 = 0 ;
8154 PyObject * obj4 = 0 ;
8155 char *kwnames[] = {
8156 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8157 };
8158
8159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8160 {
8161 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8162 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8163 } else {
8164 PyErr_Clear(); // clear the failure of the wxPyConvert above
8165 arg1 = wxPyCBInputStream_create(obj0, true);
8166 if (arg1 == NULL) {
8167 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8168 SWIG_fail;
8169 }
8170 }
8171 }
8172 {
8173 arg2 = wxString_in_helper(obj1);
8174 if (arg2 == NULL) SWIG_fail;
8175 temp2 = true;
8176 }
8177 {
8178 arg3 = wxString_in_helper(obj2);
8179 if (arg3 == NULL) SWIG_fail;
8180 temp3 = true;
8181 }
8182 {
8183 arg4 = wxString_in_helper(obj3);
8184 if (arg4 == NULL) SWIG_fail;
8185 temp4 = true;
8186 }
8187 {
8188 wxDateTime * argp;
8189 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8190 if (SWIG_arg_fail(5)) SWIG_fail;
8191 if (argp == NULL) {
8192 SWIG_null_ref("wxDateTime");
8193 }
8194 if (SWIG_arg_fail(5)) SWIG_fail;
8195 arg5 = *argp;
8196 }
8197 {
8198 PyThreadState* __tstate = wxPyBeginAllowThreads();
8199 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8200
8201 wxPyEndAllowThreads(__tstate);
8202 if (PyErr_Occurred()) SWIG_fail;
8203 }
8204 {
8205 resultobj = wxPyMake_wxObject(result, (bool)1);
8206 }
8207 {
8208 if (temp2)
8209 delete arg2;
8210 }
8211 {
8212 if (temp3)
8213 delete arg3;
8214 }
8215 {
8216 if (temp4)
8217 delete arg4;
8218 }
8219 return resultobj;
8220 fail:
8221 {
8222 if (temp2)
8223 delete arg2;
8224 }
8225 {
8226 if (temp3)
8227 delete arg3;
8228 }
8229 {
8230 if (temp4)
8231 delete arg4;
8232 }
8233 return NULL;
8234 }
8235
8236
8237 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8238 PyObject *resultobj = NULL;
8239 wxFSFile *arg1 = (wxFSFile *) 0 ;
8240 PyObject * obj0 = 0 ;
8241 char *kwnames[] = {
8242 (char *) "self", NULL
8243 };
8244
8245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8247 if (SWIG_arg_fail(1)) SWIG_fail;
8248 {
8249 PyThreadState* __tstate = wxPyBeginAllowThreads();
8250 delete arg1;
8251
8252 wxPyEndAllowThreads(__tstate);
8253 if (PyErr_Occurred()) SWIG_fail;
8254 }
8255 Py_INCREF(Py_None); resultobj = Py_None;
8256 return resultobj;
8257 fail:
8258 return NULL;
8259 }
8260
8261
8262 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8263 PyObject *resultobj = NULL;
8264 wxFSFile *arg1 = (wxFSFile *) 0 ;
8265 wxInputStream *result;
8266 PyObject * obj0 = 0 ;
8267 char *kwnames[] = {
8268 (char *) "self", NULL
8269 };
8270
8271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8273 if (SWIG_arg_fail(1)) SWIG_fail;
8274 {
8275 PyThreadState* __tstate = wxPyBeginAllowThreads();
8276 result = (wxInputStream *)(arg1)->GetStream();
8277
8278 wxPyEndAllowThreads(__tstate);
8279 if (PyErr_Occurred()) SWIG_fail;
8280 }
8281 {
8282 wxPyInputStream * _ptr = NULL;
8283
8284 if (result) {
8285 _ptr = new wxPyInputStream(result);
8286 }
8287 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8288 }
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj = NULL;
8297 wxFSFile *arg1 = (wxFSFile *) 0 ;
8298 wxString *result;
8299 PyObject * obj0 = 0 ;
8300 char *kwnames[] = {
8301 (char *) "self", NULL
8302 };
8303
8304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8306 if (SWIG_arg_fail(1)) SWIG_fail;
8307 {
8308 PyThreadState* __tstate = wxPyBeginAllowThreads();
8309 {
8310 wxString const &_result_ref = (arg1)->GetMimeType();
8311 result = (wxString *) &_result_ref;
8312 }
8313
8314 wxPyEndAllowThreads(__tstate);
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 {
8318 #if wxUSE_UNICODE
8319 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8320 #else
8321 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8322 #endif
8323 }
8324 return resultobj;
8325 fail:
8326 return NULL;
8327 }
8328
8329
8330 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8331 PyObject *resultobj = NULL;
8332 wxFSFile *arg1 = (wxFSFile *) 0 ;
8333 wxString *result;
8334 PyObject * obj0 = 0 ;
8335 char *kwnames[] = {
8336 (char *) "self", NULL
8337 };
8338
8339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8341 if (SWIG_arg_fail(1)) SWIG_fail;
8342 {
8343 PyThreadState* __tstate = wxPyBeginAllowThreads();
8344 {
8345 wxString const &_result_ref = (arg1)->GetLocation();
8346 result = (wxString *) &_result_ref;
8347 }
8348
8349 wxPyEndAllowThreads(__tstate);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 {
8353 #if wxUSE_UNICODE
8354 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8355 #else
8356 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8357 #endif
8358 }
8359 return resultobj;
8360 fail:
8361 return NULL;
8362 }
8363
8364
8365 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8366 PyObject *resultobj = NULL;
8367 wxFSFile *arg1 = (wxFSFile *) 0 ;
8368 wxString *result;
8369 PyObject * obj0 = 0 ;
8370 char *kwnames[] = {
8371 (char *) "self", NULL
8372 };
8373
8374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8376 if (SWIG_arg_fail(1)) SWIG_fail;
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 {
8380 wxString const &_result_ref = (arg1)->GetAnchor();
8381 result = (wxString *) &_result_ref;
8382 }
8383
8384 wxPyEndAllowThreads(__tstate);
8385 if (PyErr_Occurred()) SWIG_fail;
8386 }
8387 {
8388 #if wxUSE_UNICODE
8389 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8390 #else
8391 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8392 #endif
8393 }
8394 return resultobj;
8395 fail:
8396 return NULL;
8397 }
8398
8399
8400 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8401 PyObject *resultobj = NULL;
8402 wxFSFile *arg1 = (wxFSFile *) 0 ;
8403 wxDateTime result;
8404 PyObject * obj0 = 0 ;
8405 char *kwnames[] = {
8406 (char *) "self", NULL
8407 };
8408
8409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8411 if (SWIG_arg_fail(1)) SWIG_fail;
8412 {
8413 PyThreadState* __tstate = wxPyBeginAllowThreads();
8414 result = (arg1)->GetModificationTime();
8415
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 {
8420 wxDateTime * resultptr;
8421 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8422 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8423 }
8424 return resultobj;
8425 fail:
8426 return NULL;
8427 }
8428
8429
8430 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8431 PyObject *obj;
8432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8433 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8434 Py_INCREF(obj);
8435 return Py_BuildValue((char *)"");
8436 }
8437 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8438 PyObject *obj;
8439 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8440 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8441 Py_INCREF(obj);
8442 return Py_BuildValue((char *)"");
8443 }
8444 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8445 PyObject *resultobj = NULL;
8446 wxPyFileSystemHandler *result;
8447 char *kwnames[] = {
8448 NULL
8449 };
8450
8451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8452 {
8453 PyThreadState* __tstate = wxPyBeginAllowThreads();
8454 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8455
8456 wxPyEndAllowThreads(__tstate);
8457 if (PyErr_Occurred()) SWIG_fail;
8458 }
8459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8460 return resultobj;
8461 fail:
8462 return NULL;
8463 }
8464
8465
8466 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8467 PyObject *resultobj = NULL;
8468 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8469 PyObject *arg2 = (PyObject *) 0 ;
8470 PyObject *arg3 = (PyObject *) 0 ;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 PyObject * obj2 = 0 ;
8474 char *kwnames[] = {
8475 (char *) "self",(char *) "self",(char *) "_class", NULL
8476 };
8477
8478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8480 if (SWIG_arg_fail(1)) SWIG_fail;
8481 arg2 = obj1;
8482 arg3 = obj2;
8483 {
8484 PyThreadState* __tstate = wxPyBeginAllowThreads();
8485 (arg1)->_setCallbackInfo(arg2,arg3);
8486
8487 wxPyEndAllowThreads(__tstate);
8488 if (PyErr_Occurred()) SWIG_fail;
8489 }
8490 Py_INCREF(Py_None); resultobj = Py_None;
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8498 PyObject *resultobj = NULL;
8499 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8500 wxString *arg2 = 0 ;
8501 bool result;
8502 bool temp2 = false ;
8503 PyObject * obj0 = 0 ;
8504 PyObject * obj1 = 0 ;
8505 char *kwnames[] = {
8506 (char *) "self",(char *) "location", NULL
8507 };
8508
8509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8511 if (SWIG_arg_fail(1)) SWIG_fail;
8512 {
8513 arg2 = wxString_in_helper(obj1);
8514 if (arg2 == NULL) SWIG_fail;
8515 temp2 = true;
8516 }
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8520
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 {
8525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8526 }
8527 {
8528 if (temp2)
8529 delete arg2;
8530 }
8531 return resultobj;
8532 fail:
8533 {
8534 if (temp2)
8535 delete arg2;
8536 }
8537 return NULL;
8538 }
8539
8540
8541 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8542 PyObject *resultobj = NULL;
8543 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8544 wxFileSystem *arg2 = 0 ;
8545 wxString *arg3 = 0 ;
8546 wxFSFile *result;
8547 bool temp3 = false ;
8548 PyObject * obj0 = 0 ;
8549 PyObject * obj1 = 0 ;
8550 PyObject * obj2 = 0 ;
8551 char *kwnames[] = {
8552 (char *) "self",(char *) "fs",(char *) "location", NULL
8553 };
8554
8555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8557 if (SWIG_arg_fail(1)) SWIG_fail;
8558 {
8559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8560 if (SWIG_arg_fail(2)) SWIG_fail;
8561 if (arg2 == NULL) {
8562 SWIG_null_ref("wxFileSystem");
8563 }
8564 if (SWIG_arg_fail(2)) SWIG_fail;
8565 }
8566 {
8567 arg3 = wxString_in_helper(obj2);
8568 if (arg3 == NULL) SWIG_fail;
8569 temp3 = true;
8570 }
8571 {
8572 PyThreadState* __tstate = wxPyBeginAllowThreads();
8573 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8574
8575 wxPyEndAllowThreads(__tstate);
8576 if (PyErr_Occurred()) SWIG_fail;
8577 }
8578 {
8579 resultobj = wxPyMake_wxObject(result, (bool)1);
8580 }
8581 {
8582 if (temp3)
8583 delete arg3;
8584 }
8585 return resultobj;
8586 fail:
8587 {
8588 if (temp3)
8589 delete arg3;
8590 }
8591 return NULL;
8592 }
8593
8594
8595 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj = NULL;
8597 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8598 wxString *arg2 = 0 ;
8599 int arg3 = (int) 0 ;
8600 wxString result;
8601 bool temp2 = false ;
8602 PyObject * obj0 = 0 ;
8603 PyObject * obj1 = 0 ;
8604 PyObject * obj2 = 0 ;
8605 char *kwnames[] = {
8606 (char *) "self",(char *) "spec",(char *) "flags", NULL
8607 };
8608
8609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8611 if (SWIG_arg_fail(1)) SWIG_fail;
8612 {
8613 arg2 = wxString_in_helper(obj1);
8614 if (arg2 == NULL) SWIG_fail;
8615 temp2 = true;
8616 }
8617 if (obj2) {
8618 {
8619 arg3 = static_cast<int >(SWIG_As_int(obj2));
8620 if (SWIG_arg_fail(3)) SWIG_fail;
8621 }
8622 }
8623 {
8624 PyThreadState* __tstate = wxPyBeginAllowThreads();
8625 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8626
8627 wxPyEndAllowThreads(__tstate);
8628 if (PyErr_Occurred()) SWIG_fail;
8629 }
8630 {
8631 #if wxUSE_UNICODE
8632 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8633 #else
8634 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8635 #endif
8636 }
8637 {
8638 if (temp2)
8639 delete arg2;
8640 }
8641 return resultobj;
8642 fail:
8643 {
8644 if (temp2)
8645 delete arg2;
8646 }
8647 return NULL;
8648 }
8649
8650
8651 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj = NULL;
8653 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8654 wxString result;
8655 PyObject * obj0 = 0 ;
8656 char *kwnames[] = {
8657 (char *) "self", NULL
8658 };
8659
8660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8662 if (SWIG_arg_fail(1)) SWIG_fail;
8663 {
8664 PyThreadState* __tstate = wxPyBeginAllowThreads();
8665 result = (arg1)->FindNext();
8666
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 {
8671 #if wxUSE_UNICODE
8672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8673 #else
8674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8675 #endif
8676 }
8677 return resultobj;
8678 fail:
8679 return NULL;
8680 }
8681
8682
8683 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8684 PyObject *resultobj = NULL;
8685 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8686 wxString *arg2 = 0 ;
8687 wxString result;
8688 bool temp2 = false ;
8689 PyObject * obj0 = 0 ;
8690 PyObject * obj1 = 0 ;
8691 char *kwnames[] = {
8692 (char *) "self",(char *) "location", NULL
8693 };
8694
8695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8697 if (SWIG_arg_fail(1)) SWIG_fail;
8698 {
8699 arg2 = wxString_in_helper(obj1);
8700 if (arg2 == NULL) SWIG_fail;
8701 temp2 = true;
8702 }
8703 {
8704 PyThreadState* __tstate = wxPyBeginAllowThreads();
8705 result = (arg1)->GetProtocol((wxString const &)*arg2);
8706
8707 wxPyEndAllowThreads(__tstate);
8708 if (PyErr_Occurred()) SWIG_fail;
8709 }
8710 {
8711 #if wxUSE_UNICODE
8712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8713 #else
8714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8715 #endif
8716 }
8717 {
8718 if (temp2)
8719 delete arg2;
8720 }
8721 return resultobj;
8722 fail:
8723 {
8724 if (temp2)
8725 delete arg2;
8726 }
8727 return NULL;
8728 }
8729
8730
8731 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8732 PyObject *resultobj = NULL;
8733 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8734 wxString *arg2 = 0 ;
8735 wxString result;
8736 bool temp2 = false ;
8737 PyObject * obj0 = 0 ;
8738 PyObject * obj1 = 0 ;
8739 char *kwnames[] = {
8740 (char *) "self",(char *) "location", NULL
8741 };
8742
8743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8745 if (SWIG_arg_fail(1)) SWIG_fail;
8746 {
8747 arg2 = wxString_in_helper(obj1);
8748 if (arg2 == NULL) SWIG_fail;
8749 temp2 = true;
8750 }
8751 {
8752 PyThreadState* __tstate = wxPyBeginAllowThreads();
8753 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8754
8755 wxPyEndAllowThreads(__tstate);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 {
8759 #if wxUSE_UNICODE
8760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8761 #else
8762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8763 #endif
8764 }
8765 {
8766 if (temp2)
8767 delete arg2;
8768 }
8769 return resultobj;
8770 fail:
8771 {
8772 if (temp2)
8773 delete arg2;
8774 }
8775 return NULL;
8776 }
8777
8778
8779 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8780 PyObject *resultobj = NULL;
8781 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8782 wxString *arg2 = 0 ;
8783 wxString result;
8784 bool temp2 = false ;
8785 PyObject * obj0 = 0 ;
8786 PyObject * obj1 = 0 ;
8787 char *kwnames[] = {
8788 (char *) "self",(char *) "location", NULL
8789 };
8790
8791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8793 if (SWIG_arg_fail(1)) SWIG_fail;
8794 {
8795 arg2 = wxString_in_helper(obj1);
8796 if (arg2 == NULL) SWIG_fail;
8797 temp2 = true;
8798 }
8799 {
8800 PyThreadState* __tstate = wxPyBeginAllowThreads();
8801 result = (arg1)->GetAnchor((wxString const &)*arg2);
8802
8803 wxPyEndAllowThreads(__tstate);
8804 if (PyErr_Occurred()) SWIG_fail;
8805 }
8806 {
8807 #if wxUSE_UNICODE
8808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8809 #else
8810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8811 #endif
8812 }
8813 {
8814 if (temp2)
8815 delete arg2;
8816 }
8817 return resultobj;
8818 fail:
8819 {
8820 if (temp2)
8821 delete arg2;
8822 }
8823 return NULL;
8824 }
8825
8826
8827 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8828 PyObject *resultobj = NULL;
8829 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8830 wxString *arg2 = 0 ;
8831 wxString result;
8832 bool temp2 = false ;
8833 PyObject * obj0 = 0 ;
8834 PyObject * obj1 = 0 ;
8835 char *kwnames[] = {
8836 (char *) "self",(char *) "location", NULL
8837 };
8838
8839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8841 if (SWIG_arg_fail(1)) SWIG_fail;
8842 {
8843 arg2 = wxString_in_helper(obj1);
8844 if (arg2 == NULL) SWIG_fail;
8845 temp2 = true;
8846 }
8847 {
8848 PyThreadState* __tstate = wxPyBeginAllowThreads();
8849 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8850
8851 wxPyEndAllowThreads(__tstate);
8852 if (PyErr_Occurred()) SWIG_fail;
8853 }
8854 {
8855 #if wxUSE_UNICODE
8856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8857 #else
8858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8859 #endif
8860 }
8861 {
8862 if (temp2)
8863 delete arg2;
8864 }
8865 return resultobj;
8866 fail:
8867 {
8868 if (temp2)
8869 delete arg2;
8870 }
8871 return NULL;
8872 }
8873
8874
8875 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8876 PyObject *resultobj = NULL;
8877 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8878 wxString *arg2 = 0 ;
8879 wxString result;
8880 bool temp2 = false ;
8881 PyObject * obj0 = 0 ;
8882 PyObject * obj1 = 0 ;
8883 char *kwnames[] = {
8884 (char *) "self",(char *) "location", NULL
8885 };
8886
8887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8889 if (SWIG_arg_fail(1)) SWIG_fail;
8890 {
8891 arg2 = wxString_in_helper(obj1);
8892 if (arg2 == NULL) SWIG_fail;
8893 temp2 = true;
8894 }
8895 {
8896 PyThreadState* __tstate = wxPyBeginAllowThreads();
8897 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8898
8899 wxPyEndAllowThreads(__tstate);
8900 if (PyErr_Occurred()) SWIG_fail;
8901 }
8902 {
8903 #if wxUSE_UNICODE
8904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8905 #else
8906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8907 #endif
8908 }
8909 {
8910 if (temp2)
8911 delete arg2;
8912 }
8913 return resultobj;
8914 fail:
8915 {
8916 if (temp2)
8917 delete arg2;
8918 }
8919 return NULL;
8920 }
8921
8922
8923 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8924 PyObject *obj;
8925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8926 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8927 Py_INCREF(obj);
8928 return Py_BuildValue((char *)"");
8929 }
8930 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj = NULL;
8932 wxFileSystem *result;
8933 char *kwnames[] = {
8934 NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8938 {
8939 PyThreadState* __tstate = wxPyBeginAllowThreads();
8940 result = (wxFileSystem *)new wxFileSystem();
8941
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 {
8946 resultobj = wxPyMake_wxObject(result, (bool)1);
8947 }
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj = NULL;
8956 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8957 PyObject * obj0 = 0 ;
8958 char *kwnames[] = {
8959 (char *) "self", NULL
8960 };
8961
8962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8964 if (SWIG_arg_fail(1)) SWIG_fail;
8965 {
8966 PyThreadState* __tstate = wxPyBeginAllowThreads();
8967 delete arg1;
8968
8969 wxPyEndAllowThreads(__tstate);
8970 if (PyErr_Occurred()) SWIG_fail;
8971 }
8972 Py_INCREF(Py_None); resultobj = Py_None;
8973 return resultobj;
8974 fail:
8975 return NULL;
8976 }
8977
8978
8979 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8980 PyObject *resultobj = NULL;
8981 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8982 wxString *arg2 = 0 ;
8983 bool arg3 = (bool) false ;
8984 bool temp2 = false ;
8985 PyObject * obj0 = 0 ;
8986 PyObject * obj1 = 0 ;
8987 PyObject * obj2 = 0 ;
8988 char *kwnames[] = {
8989 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8990 };
8991
8992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8994 if (SWIG_arg_fail(1)) SWIG_fail;
8995 {
8996 arg2 = wxString_in_helper(obj1);
8997 if (arg2 == NULL) SWIG_fail;
8998 temp2 = true;
8999 }
9000 if (obj2) {
9001 {
9002 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
9003 if (SWIG_arg_fail(3)) SWIG_fail;
9004 }
9005 }
9006 {
9007 PyThreadState* __tstate = wxPyBeginAllowThreads();
9008 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
9009
9010 wxPyEndAllowThreads(__tstate);
9011 if (PyErr_Occurred()) SWIG_fail;
9012 }
9013 Py_INCREF(Py_None); resultobj = Py_None;
9014 {
9015 if (temp2)
9016 delete arg2;
9017 }
9018 return resultobj;
9019 fail:
9020 {
9021 if (temp2)
9022 delete arg2;
9023 }
9024 return NULL;
9025 }
9026
9027
9028 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
9029 PyObject *resultobj = NULL;
9030 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9031 wxString result;
9032 PyObject * obj0 = 0 ;
9033 char *kwnames[] = {
9034 (char *) "self", NULL
9035 };
9036
9037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
9038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9039 if (SWIG_arg_fail(1)) SWIG_fail;
9040 {
9041 PyThreadState* __tstate = wxPyBeginAllowThreads();
9042 result = (arg1)->GetPath();
9043
9044 wxPyEndAllowThreads(__tstate);
9045 if (PyErr_Occurred()) SWIG_fail;
9046 }
9047 {
9048 #if wxUSE_UNICODE
9049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9050 #else
9051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9052 #endif
9053 }
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9061 PyObject *resultobj = NULL;
9062 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9063 wxString *arg2 = 0 ;
9064 wxFSFile *result;
9065 bool temp2 = false ;
9066 PyObject * obj0 = 0 ;
9067 PyObject * obj1 = 0 ;
9068 char *kwnames[] = {
9069 (char *) "self",(char *) "location", NULL
9070 };
9071
9072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9074 if (SWIG_arg_fail(1)) SWIG_fail;
9075 {
9076 arg2 = wxString_in_helper(obj1);
9077 if (arg2 == NULL) SWIG_fail;
9078 temp2 = true;
9079 }
9080 {
9081 PyThreadState* __tstate = wxPyBeginAllowThreads();
9082 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9083
9084 wxPyEndAllowThreads(__tstate);
9085 if (PyErr_Occurred()) SWIG_fail;
9086 }
9087 {
9088 resultobj = wxPyMake_wxObject(result, (bool)1);
9089 }
9090 {
9091 if (temp2)
9092 delete arg2;
9093 }
9094 return resultobj;
9095 fail:
9096 {
9097 if (temp2)
9098 delete arg2;
9099 }
9100 return NULL;
9101 }
9102
9103
9104 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9105 PyObject *resultobj = NULL;
9106 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9107 wxString *arg2 = 0 ;
9108 int arg3 = (int) 0 ;
9109 wxString result;
9110 bool temp2 = false ;
9111 PyObject * obj0 = 0 ;
9112 PyObject * obj1 = 0 ;
9113 PyObject * obj2 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "self",(char *) "spec",(char *) "flags", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9120 if (SWIG_arg_fail(1)) SWIG_fail;
9121 {
9122 arg2 = wxString_in_helper(obj1);
9123 if (arg2 == NULL) SWIG_fail;
9124 temp2 = true;
9125 }
9126 if (obj2) {
9127 {
9128 arg3 = static_cast<int >(SWIG_As_int(obj2));
9129 if (SWIG_arg_fail(3)) SWIG_fail;
9130 }
9131 }
9132 {
9133 PyThreadState* __tstate = wxPyBeginAllowThreads();
9134 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9135
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 {
9140 #if wxUSE_UNICODE
9141 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9142 #else
9143 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9144 #endif
9145 }
9146 {
9147 if (temp2)
9148 delete arg2;
9149 }
9150 return resultobj;
9151 fail:
9152 {
9153 if (temp2)
9154 delete arg2;
9155 }
9156 return NULL;
9157 }
9158
9159
9160 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj = NULL;
9162 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9163 wxString result;
9164 PyObject * obj0 = 0 ;
9165 char *kwnames[] = {
9166 (char *) "self", NULL
9167 };
9168
9169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9171 if (SWIG_arg_fail(1)) SWIG_fail;
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 result = (arg1)->FindNext();
9175
9176 wxPyEndAllowThreads(__tstate);
9177 if (PyErr_Occurred()) SWIG_fail;
9178 }
9179 {
9180 #if wxUSE_UNICODE
9181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9182 #else
9183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9184 #endif
9185 }
9186 return resultobj;
9187 fail:
9188 return NULL;
9189 }
9190
9191
9192 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9193 PyObject *resultobj = NULL;
9194 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9195 PyObject * obj0 = 0 ;
9196 char *kwnames[] = {
9197 (char *) "handler", NULL
9198 };
9199
9200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9202 if (SWIG_arg_fail(1)) SWIG_fail;
9203 {
9204 PyThreadState* __tstate = wxPyBeginAllowThreads();
9205 wxFileSystem::AddHandler(arg1);
9206
9207 wxPyEndAllowThreads(__tstate);
9208 if (PyErr_Occurred()) SWIG_fail;
9209 }
9210 Py_INCREF(Py_None); resultobj = Py_None;
9211 return resultobj;
9212 fail:
9213 return NULL;
9214 }
9215
9216
9217 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9218 PyObject *resultobj = NULL;
9219 char *kwnames[] = {
9220 NULL
9221 };
9222
9223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 wxFileSystem::CleanUpHandlers();
9227
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 Py_INCREF(Py_None); resultobj = Py_None;
9232 return resultobj;
9233 fail:
9234 return NULL;
9235 }
9236
9237
9238 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9239 PyObject *resultobj = NULL;
9240 wxString *arg1 = 0 ;
9241 wxString result;
9242 bool temp1 = false ;
9243 PyObject * obj0 = 0 ;
9244 char *kwnames[] = {
9245 (char *) "filename", NULL
9246 };
9247
9248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9249 {
9250 arg1 = wxString_in_helper(obj0);
9251 if (arg1 == NULL) SWIG_fail;
9252 temp1 = true;
9253 }
9254 {
9255 PyThreadState* __tstate = wxPyBeginAllowThreads();
9256 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9257
9258 wxPyEndAllowThreads(__tstate);
9259 if (PyErr_Occurred()) SWIG_fail;
9260 }
9261 {
9262 #if wxUSE_UNICODE
9263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9264 #else
9265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9266 #endif
9267 }
9268 {
9269 if (temp1)
9270 delete arg1;
9271 }
9272 return resultobj;
9273 fail:
9274 {
9275 if (temp1)
9276 delete arg1;
9277 }
9278 return NULL;
9279 }
9280
9281
9282 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9283 PyObject *resultobj = NULL;
9284 wxString *arg1 = 0 ;
9285 wxString result;
9286 bool temp1 = false ;
9287 PyObject * obj0 = 0 ;
9288 char *kwnames[] = {
9289 (char *) "url", NULL
9290 };
9291
9292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9293 {
9294 arg1 = wxString_in_helper(obj0);
9295 if (arg1 == NULL) SWIG_fail;
9296 temp1 = true;
9297 }
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 {
9306 #if wxUSE_UNICODE
9307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9308 #else
9309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9310 #endif
9311 }
9312 {
9313 if (temp1)
9314 delete arg1;
9315 }
9316 return resultobj;
9317 fail:
9318 {
9319 if (temp1)
9320 delete arg1;
9321 }
9322 return NULL;
9323 }
9324
9325
9326 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9327 PyObject *obj;
9328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9329 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9330 Py_INCREF(obj);
9331 return Py_BuildValue((char *)"");
9332 }
9333 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9334 PyObject *resultobj = NULL;
9335 wxInternetFSHandler *result;
9336 char *kwnames[] = {
9337 NULL
9338 };
9339
9340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9341 {
9342 PyThreadState* __tstate = wxPyBeginAllowThreads();
9343 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9344
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9356 PyObject *resultobj = NULL;
9357 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9358 wxString *arg2 = 0 ;
9359 bool result;
9360 bool temp2 = false ;
9361 PyObject * obj0 = 0 ;
9362 PyObject * obj1 = 0 ;
9363 char *kwnames[] = {
9364 (char *) "self",(char *) "location", NULL
9365 };
9366
9367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9369 if (SWIG_arg_fail(1)) SWIG_fail;
9370 {
9371 arg2 = wxString_in_helper(obj1);
9372 if (arg2 == NULL) SWIG_fail;
9373 temp2 = true;
9374 }
9375 {
9376 PyThreadState* __tstate = wxPyBeginAllowThreads();
9377 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9378
9379 wxPyEndAllowThreads(__tstate);
9380 if (PyErr_Occurred()) SWIG_fail;
9381 }
9382 {
9383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9384 }
9385 {
9386 if (temp2)
9387 delete arg2;
9388 }
9389 return resultobj;
9390 fail:
9391 {
9392 if (temp2)
9393 delete arg2;
9394 }
9395 return NULL;
9396 }
9397
9398
9399 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9400 PyObject *resultobj = NULL;
9401 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9402 wxFileSystem *arg2 = 0 ;
9403 wxString *arg3 = 0 ;
9404 wxFSFile *result;
9405 bool temp3 = false ;
9406 PyObject * obj0 = 0 ;
9407 PyObject * obj1 = 0 ;
9408 PyObject * obj2 = 0 ;
9409 char *kwnames[] = {
9410 (char *) "self",(char *) "fs",(char *) "location", NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9415 if (SWIG_arg_fail(1)) SWIG_fail;
9416 {
9417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9418 if (SWIG_arg_fail(2)) SWIG_fail;
9419 if (arg2 == NULL) {
9420 SWIG_null_ref("wxFileSystem");
9421 }
9422 if (SWIG_arg_fail(2)) SWIG_fail;
9423 }
9424 {
9425 arg3 = wxString_in_helper(obj2);
9426 if (arg3 == NULL) SWIG_fail;
9427 temp3 = true;
9428 }
9429 {
9430 PyThreadState* __tstate = wxPyBeginAllowThreads();
9431 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9432
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 {
9437 resultobj = wxPyMake_wxObject(result, (bool)1);
9438 }
9439 {
9440 if (temp3)
9441 delete arg3;
9442 }
9443 return resultobj;
9444 fail:
9445 {
9446 if (temp3)
9447 delete arg3;
9448 }
9449 return NULL;
9450 }
9451
9452
9453 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9454 PyObject *obj;
9455 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9456 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9457 Py_INCREF(obj);
9458 return Py_BuildValue((char *)"");
9459 }
9460 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9461 PyObject *resultobj = NULL;
9462 wxZipFSHandler *result;
9463 char *kwnames[] = {
9464 NULL
9465 };
9466
9467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9468 {
9469 PyThreadState* __tstate = wxPyBeginAllowThreads();
9470 result = (wxZipFSHandler *)new wxZipFSHandler();
9471
9472 wxPyEndAllowThreads(__tstate);
9473 if (PyErr_Occurred()) SWIG_fail;
9474 }
9475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9483 PyObject *resultobj = NULL;
9484 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9485 wxString *arg2 = 0 ;
9486 bool result;
9487 bool temp2 = false ;
9488 PyObject * obj0 = 0 ;
9489 PyObject * obj1 = 0 ;
9490 char *kwnames[] = {
9491 (char *) "self",(char *) "location", NULL
9492 };
9493
9494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9496 if (SWIG_arg_fail(1)) SWIG_fail;
9497 {
9498 arg2 = wxString_in_helper(obj1);
9499 if (arg2 == NULL) SWIG_fail;
9500 temp2 = true;
9501 }
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9505
9506 wxPyEndAllowThreads(__tstate);
9507 if (PyErr_Occurred()) SWIG_fail;
9508 }
9509 {
9510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9511 }
9512 {
9513 if (temp2)
9514 delete arg2;
9515 }
9516 return resultobj;
9517 fail:
9518 {
9519 if (temp2)
9520 delete arg2;
9521 }
9522 return NULL;
9523 }
9524
9525
9526 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9527 PyObject *resultobj = NULL;
9528 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9529 wxFileSystem *arg2 = 0 ;
9530 wxString *arg3 = 0 ;
9531 wxFSFile *result;
9532 bool temp3 = false ;
9533 PyObject * obj0 = 0 ;
9534 PyObject * obj1 = 0 ;
9535 PyObject * obj2 = 0 ;
9536 char *kwnames[] = {
9537 (char *) "self",(char *) "fs",(char *) "location", NULL
9538 };
9539
9540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9542 if (SWIG_arg_fail(1)) SWIG_fail;
9543 {
9544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9545 if (SWIG_arg_fail(2)) SWIG_fail;
9546 if (arg2 == NULL) {
9547 SWIG_null_ref("wxFileSystem");
9548 }
9549 if (SWIG_arg_fail(2)) SWIG_fail;
9550 }
9551 {
9552 arg3 = wxString_in_helper(obj2);
9553 if (arg3 == NULL) SWIG_fail;
9554 temp3 = true;
9555 }
9556 {
9557 PyThreadState* __tstate = wxPyBeginAllowThreads();
9558 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9559
9560 wxPyEndAllowThreads(__tstate);
9561 if (PyErr_Occurred()) SWIG_fail;
9562 }
9563 {
9564 resultobj = wxPyMake_wxObject(result, (bool)1);
9565 }
9566 {
9567 if (temp3)
9568 delete arg3;
9569 }
9570 return resultobj;
9571 fail:
9572 {
9573 if (temp3)
9574 delete arg3;
9575 }
9576 return NULL;
9577 }
9578
9579
9580 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9581 PyObject *resultobj = NULL;
9582 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9583 wxString *arg2 = 0 ;
9584 int arg3 = (int) 0 ;
9585 wxString result;
9586 bool temp2 = false ;
9587 PyObject * obj0 = 0 ;
9588 PyObject * obj1 = 0 ;
9589 PyObject * obj2 = 0 ;
9590 char *kwnames[] = {
9591 (char *) "self",(char *) "spec",(char *) "flags", NULL
9592 };
9593
9594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9596 if (SWIG_arg_fail(1)) SWIG_fail;
9597 {
9598 arg2 = wxString_in_helper(obj1);
9599 if (arg2 == NULL) SWIG_fail;
9600 temp2 = true;
9601 }
9602 if (obj2) {
9603 {
9604 arg3 = static_cast<int >(SWIG_As_int(obj2));
9605 if (SWIG_arg_fail(3)) SWIG_fail;
9606 }
9607 }
9608 {
9609 PyThreadState* __tstate = wxPyBeginAllowThreads();
9610 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9611
9612 wxPyEndAllowThreads(__tstate);
9613 if (PyErr_Occurred()) SWIG_fail;
9614 }
9615 {
9616 #if wxUSE_UNICODE
9617 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9618 #else
9619 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9620 #endif
9621 }
9622 {
9623 if (temp2)
9624 delete arg2;
9625 }
9626 return resultobj;
9627 fail:
9628 {
9629 if (temp2)
9630 delete arg2;
9631 }
9632 return NULL;
9633 }
9634
9635
9636 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9637 PyObject *resultobj = NULL;
9638 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9639 wxString result;
9640 PyObject * obj0 = 0 ;
9641 char *kwnames[] = {
9642 (char *) "self", NULL
9643 };
9644
9645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9647 if (SWIG_arg_fail(1)) SWIG_fail;
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 result = (arg1)->FindNext();
9651
9652 wxPyEndAllowThreads(__tstate);
9653 if (PyErr_Occurred()) SWIG_fail;
9654 }
9655 {
9656 #if wxUSE_UNICODE
9657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9658 #else
9659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9660 #endif
9661 }
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9669 PyObject *obj;
9670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9671 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9672 Py_INCREF(obj);
9673 return Py_BuildValue((char *)"");
9674 }
9675 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9676 PyObject *resultobj = NULL;
9677 wxString *arg1 = 0 ;
9678 wxImage *arg2 = 0 ;
9679 long arg3 ;
9680 bool temp1 = false ;
9681 PyObject * obj0 = 0 ;
9682 PyObject * obj1 = 0 ;
9683 PyObject * obj2 = 0 ;
9684 char *kwnames[] = {
9685 (char *) "filename",(char *) "image",(char *) "type", NULL
9686 };
9687
9688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9689 {
9690 arg1 = wxString_in_helper(obj0);
9691 if (arg1 == NULL) SWIG_fail;
9692 temp1 = true;
9693 }
9694 {
9695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9696 if (SWIG_arg_fail(2)) SWIG_fail;
9697 if (arg2 == NULL) {
9698 SWIG_null_ref("wxImage");
9699 }
9700 if (SWIG_arg_fail(2)) SWIG_fail;
9701 }
9702 {
9703 arg3 = static_cast<long >(SWIG_As_long(obj2));
9704 if (SWIG_arg_fail(3)) SWIG_fail;
9705 }
9706 {
9707 PyThreadState* __tstate = wxPyBeginAllowThreads();
9708 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9709
9710 wxPyEndAllowThreads(__tstate);
9711 if (PyErr_Occurred()) SWIG_fail;
9712 }
9713 Py_INCREF(Py_None); resultobj = Py_None;
9714 {
9715 if (temp1)
9716 delete arg1;
9717 }
9718 return resultobj;
9719 fail:
9720 {
9721 if (temp1)
9722 delete arg1;
9723 }
9724 return NULL;
9725 }
9726
9727
9728 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9729 PyObject *resultobj = NULL;
9730 wxString *arg1 = 0 ;
9731 wxBitmap *arg2 = 0 ;
9732 long arg3 ;
9733 bool temp1 = false ;
9734 PyObject * obj0 = 0 ;
9735 PyObject * obj1 = 0 ;
9736 PyObject * obj2 = 0 ;
9737 char *kwnames[] = {
9738 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9739 };
9740
9741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9742 {
9743 arg1 = wxString_in_helper(obj0);
9744 if (arg1 == NULL) SWIG_fail;
9745 temp1 = true;
9746 }
9747 {
9748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9749 if (SWIG_arg_fail(2)) SWIG_fail;
9750 if (arg2 == NULL) {
9751 SWIG_null_ref("wxBitmap");
9752 }
9753 if (SWIG_arg_fail(2)) SWIG_fail;
9754 }
9755 {
9756 arg3 = static_cast<long >(SWIG_As_long(obj2));
9757 if (SWIG_arg_fail(3)) SWIG_fail;
9758 }
9759 {
9760 PyThreadState* __tstate = wxPyBeginAllowThreads();
9761 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9762
9763 wxPyEndAllowThreads(__tstate);
9764 if (PyErr_Occurred()) SWIG_fail;
9765 }
9766 Py_INCREF(Py_None); resultobj = Py_None;
9767 {
9768 if (temp1)
9769 delete arg1;
9770 }
9771 return resultobj;
9772 fail:
9773 {
9774 if (temp1)
9775 delete arg1;
9776 }
9777 return NULL;
9778 }
9779
9780
9781 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9782 PyObject *resultobj = NULL;
9783 wxString *arg1 = 0 ;
9784 PyObject *arg2 = (PyObject *) 0 ;
9785 bool temp1 = false ;
9786 PyObject * obj0 = 0 ;
9787 PyObject * obj1 = 0 ;
9788 char *kwnames[] = {
9789 (char *) "filename",(char *) "data", NULL
9790 };
9791
9792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9793 {
9794 arg1 = wxString_in_helper(obj0);
9795 if (arg1 == NULL) SWIG_fail;
9796 temp1 = true;
9797 }
9798 arg2 = obj1;
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9802
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 Py_INCREF(Py_None); resultobj = Py_None;
9807 {
9808 if (temp1)
9809 delete arg1;
9810 }
9811 return resultobj;
9812 fail:
9813 {
9814 if (temp1)
9815 delete arg1;
9816 }
9817 return NULL;
9818 }
9819
9820
9821 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9822 PyObject *resultobj = NULL;
9823 wxMemoryFSHandler *result;
9824 char *kwnames[] = {
9825 NULL
9826 };
9827
9828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9832
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj = NULL;
9845 wxString *arg1 = 0 ;
9846 bool temp1 = false ;
9847 PyObject * obj0 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "filename", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9853 {
9854 arg1 = wxString_in_helper(obj0);
9855 if (arg1 == NULL) SWIG_fail;
9856 temp1 = true;
9857 }
9858 {
9859 PyThreadState* __tstate = wxPyBeginAllowThreads();
9860 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9861
9862 wxPyEndAllowThreads(__tstate);
9863 if (PyErr_Occurred()) SWIG_fail;
9864 }
9865 Py_INCREF(Py_None); resultobj = Py_None;
9866 {
9867 if (temp1)
9868 delete arg1;
9869 }
9870 return resultobj;
9871 fail:
9872 {
9873 if (temp1)
9874 delete arg1;
9875 }
9876 return NULL;
9877 }
9878
9879
9880 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj = NULL;
9882 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9883 wxString *arg2 = 0 ;
9884 bool result;
9885 bool temp2 = false ;
9886 PyObject * obj0 = 0 ;
9887 PyObject * obj1 = 0 ;
9888 char *kwnames[] = {
9889 (char *) "self",(char *) "location", NULL
9890 };
9891
9892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9894 if (SWIG_arg_fail(1)) SWIG_fail;
9895 {
9896 arg2 = wxString_in_helper(obj1);
9897 if (arg2 == NULL) SWIG_fail;
9898 temp2 = true;
9899 }
9900 {
9901 PyThreadState* __tstate = wxPyBeginAllowThreads();
9902 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9903
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9909 }
9910 {
9911 if (temp2)
9912 delete arg2;
9913 }
9914 return resultobj;
9915 fail:
9916 {
9917 if (temp2)
9918 delete arg2;
9919 }
9920 return NULL;
9921 }
9922
9923
9924 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9925 PyObject *resultobj = NULL;
9926 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9927 wxFileSystem *arg2 = 0 ;
9928 wxString *arg3 = 0 ;
9929 wxFSFile *result;
9930 bool temp3 = false ;
9931 PyObject * obj0 = 0 ;
9932 PyObject * obj1 = 0 ;
9933 PyObject * obj2 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "self",(char *) "fs",(char *) "location", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9940 if (SWIG_arg_fail(1)) SWIG_fail;
9941 {
9942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9943 if (SWIG_arg_fail(2)) SWIG_fail;
9944 if (arg2 == NULL) {
9945 SWIG_null_ref("wxFileSystem");
9946 }
9947 if (SWIG_arg_fail(2)) SWIG_fail;
9948 }
9949 {
9950 arg3 = wxString_in_helper(obj2);
9951 if (arg3 == NULL) SWIG_fail;
9952 temp3 = true;
9953 }
9954 {
9955 PyThreadState* __tstate = wxPyBeginAllowThreads();
9956 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9957
9958 wxPyEndAllowThreads(__tstate);
9959 if (PyErr_Occurred()) SWIG_fail;
9960 }
9961 {
9962 resultobj = wxPyMake_wxObject(result, (bool)1);
9963 }
9964 {
9965 if (temp3)
9966 delete arg3;
9967 }
9968 return resultobj;
9969 fail:
9970 {
9971 if (temp3)
9972 delete arg3;
9973 }
9974 return NULL;
9975 }
9976
9977
9978 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9979 PyObject *resultobj = NULL;
9980 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9981 wxString *arg2 = 0 ;
9982 int arg3 = (int) 0 ;
9983 wxString result;
9984 bool temp2 = false ;
9985 PyObject * obj0 = 0 ;
9986 PyObject * obj1 = 0 ;
9987 PyObject * obj2 = 0 ;
9988 char *kwnames[] = {
9989 (char *) "self",(char *) "spec",(char *) "flags", NULL
9990 };
9991
9992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9994 if (SWIG_arg_fail(1)) SWIG_fail;
9995 {
9996 arg2 = wxString_in_helper(obj1);
9997 if (arg2 == NULL) SWIG_fail;
9998 temp2 = true;
9999 }
10000 if (obj2) {
10001 {
10002 arg3 = static_cast<int >(SWIG_As_int(obj2));
10003 if (SWIG_arg_fail(3)) SWIG_fail;
10004 }
10005 }
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10009
10010 wxPyEndAllowThreads(__tstate);
10011 if (PyErr_Occurred()) SWIG_fail;
10012 }
10013 {
10014 #if wxUSE_UNICODE
10015 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10016 #else
10017 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10018 #endif
10019 }
10020 {
10021 if (temp2)
10022 delete arg2;
10023 }
10024 return resultobj;
10025 fail:
10026 {
10027 if (temp2)
10028 delete arg2;
10029 }
10030 return NULL;
10031 }
10032
10033
10034 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
10035 PyObject *resultobj = NULL;
10036 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
10037 wxString result;
10038 PyObject * obj0 = 0 ;
10039 char *kwnames[] = {
10040 (char *) "self", NULL
10041 };
10042
10043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
10044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10045 if (SWIG_arg_fail(1)) SWIG_fail;
10046 {
10047 PyThreadState* __tstate = wxPyBeginAllowThreads();
10048 result = (arg1)->FindNext();
10049
10050 wxPyEndAllowThreads(__tstate);
10051 if (PyErr_Occurred()) SWIG_fail;
10052 }
10053 {
10054 #if wxUSE_UNICODE
10055 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10056 #else
10057 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10058 #endif
10059 }
10060 return resultobj;
10061 fail:
10062 return NULL;
10063 }
10064
10065
10066 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10067 PyObject *obj;
10068 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10069 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10070 Py_INCREF(obj);
10071 return Py_BuildValue((char *)"");
10072 }
10073 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10074 PyObject *resultobj = NULL;
10075 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10076 wxString result;
10077 PyObject * obj0 = 0 ;
10078 char *kwnames[] = {
10079 (char *) "self", NULL
10080 };
10081
10082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10084 if (SWIG_arg_fail(1)) SWIG_fail;
10085 {
10086 PyThreadState* __tstate = wxPyBeginAllowThreads();
10087 result = (arg1)->GetName();
10088
10089 wxPyEndAllowThreads(__tstate);
10090 if (PyErr_Occurred()) SWIG_fail;
10091 }
10092 {
10093 #if wxUSE_UNICODE
10094 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10095 #else
10096 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10097 #endif
10098 }
10099 return resultobj;
10100 fail:
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj = NULL;
10107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10108 wxString result;
10109 PyObject * obj0 = 0 ;
10110 char *kwnames[] = {
10111 (char *) "self", NULL
10112 };
10113
10114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
10115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10116 if (SWIG_arg_fail(1)) SWIG_fail;
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 result = (arg1)->GetExtension();
10120
10121 wxPyEndAllowThreads(__tstate);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 {
10125 #if wxUSE_UNICODE
10126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10127 #else
10128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10129 #endif
10130 }
10131 return resultobj;
10132 fail:
10133 return NULL;
10134 }
10135
10136
10137 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj = NULL;
10139 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10140 long result;
10141 PyObject * obj0 = 0 ;
10142 char *kwnames[] = {
10143 (char *) "self", NULL
10144 };
10145
10146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10148 if (SWIG_arg_fail(1)) SWIG_fail;
10149 {
10150 PyThreadState* __tstate = wxPyBeginAllowThreads();
10151 result = (long)(arg1)->GetType();
10152
10153 wxPyEndAllowThreads(__tstate);
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 {
10157 resultobj = SWIG_From_long(static_cast<long >(result));
10158 }
10159 return resultobj;
10160 fail:
10161 return NULL;
10162 }
10163
10164
10165 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10166 PyObject *resultobj = NULL;
10167 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10168 wxString result;
10169 PyObject * obj0 = 0 ;
10170 char *kwnames[] = {
10171 (char *) "self", NULL
10172 };
10173
10174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10176 if (SWIG_arg_fail(1)) SWIG_fail;
10177 {
10178 PyThreadState* __tstate = wxPyBeginAllowThreads();
10179 result = (arg1)->GetMimeType();
10180
10181 wxPyEndAllowThreads(__tstate);
10182 if (PyErr_Occurred()) SWIG_fail;
10183 }
10184 {
10185 #if wxUSE_UNICODE
10186 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10187 #else
10188 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10189 #endif
10190 }
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = NULL;
10199 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10200 wxString *arg2 = 0 ;
10201 bool result;
10202 bool temp2 = false ;
10203 PyObject * obj0 = 0 ;
10204 PyObject * obj1 = 0 ;
10205 char *kwnames[] = {
10206 (char *) "self",(char *) "name", NULL
10207 };
10208
10209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10211 if (SWIG_arg_fail(1)) SWIG_fail;
10212 {
10213 arg2 = wxString_in_helper(obj1);
10214 if (arg2 == NULL) SWIG_fail;
10215 temp2 = true;
10216 }
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10220
10221 wxPyEndAllowThreads(__tstate);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 {
10225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10226 }
10227 {
10228 if (temp2)
10229 delete arg2;
10230 }
10231 return resultobj;
10232 fail:
10233 {
10234 if (temp2)
10235 delete arg2;
10236 }
10237 return NULL;
10238 }
10239
10240
10241 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10242 PyObject *resultobj = NULL;
10243 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10244 wxString *arg2 = 0 ;
10245 bool temp2 = false ;
10246 PyObject * obj0 = 0 ;
10247 PyObject * obj1 = 0 ;
10248 char *kwnames[] = {
10249 (char *) "self",(char *) "name", NULL
10250 };
10251
10252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10254 if (SWIG_arg_fail(1)) SWIG_fail;
10255 {
10256 arg2 = wxString_in_helper(obj1);
10257 if (arg2 == NULL) SWIG_fail;
10258 temp2 = true;
10259 }
10260 {
10261 PyThreadState* __tstate = wxPyBeginAllowThreads();
10262 (arg1)->SetName((wxString const &)*arg2);
10263
10264 wxPyEndAllowThreads(__tstate);
10265 if (PyErr_Occurred()) SWIG_fail;
10266 }
10267 Py_INCREF(Py_None); resultobj = Py_None;
10268 {
10269 if (temp2)
10270 delete arg2;
10271 }
10272 return resultobj;
10273 fail:
10274 {
10275 if (temp2)
10276 delete arg2;
10277 }
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj = NULL;
10284 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10285 wxString *arg2 = 0 ;
10286 bool temp2 = false ;
10287 PyObject * obj0 = 0 ;
10288 PyObject * obj1 = 0 ;
10289 char *kwnames[] = {
10290 (char *) "self",(char *) "extension", NULL
10291 };
10292
10293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10295 if (SWIG_arg_fail(1)) SWIG_fail;
10296 {
10297 arg2 = wxString_in_helper(obj1);
10298 if (arg2 == NULL) SWIG_fail;
10299 temp2 = true;
10300 }
10301 {
10302 PyThreadState* __tstate = wxPyBeginAllowThreads();
10303 (arg1)->SetExtension((wxString const &)*arg2);
10304
10305 wxPyEndAllowThreads(__tstate);
10306 if (PyErr_Occurred()) SWIG_fail;
10307 }
10308 Py_INCREF(Py_None); resultobj = Py_None;
10309 {
10310 if (temp2)
10311 delete arg2;
10312 }
10313 return resultobj;
10314 fail:
10315 {
10316 if (temp2)
10317 delete arg2;
10318 }
10319 return NULL;
10320 }
10321
10322
10323 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10324 PyObject *resultobj = NULL;
10325 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10326 long arg2 ;
10327 PyObject * obj0 = 0 ;
10328 PyObject * obj1 = 0 ;
10329 char *kwnames[] = {
10330 (char *) "self",(char *) "type", NULL
10331 };
10332
10333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10335 if (SWIG_arg_fail(1)) SWIG_fail;
10336 {
10337 arg2 = static_cast<long >(SWIG_As_long(obj1));
10338 if (SWIG_arg_fail(2)) SWIG_fail;
10339 }
10340 {
10341 PyThreadState* __tstate = wxPyBeginAllowThreads();
10342 (arg1)->SetType(arg2);
10343
10344 wxPyEndAllowThreads(__tstate);
10345 if (PyErr_Occurred()) SWIG_fail;
10346 }
10347 Py_INCREF(Py_None); resultobj = Py_None;
10348 return resultobj;
10349 fail:
10350 return NULL;
10351 }
10352
10353
10354 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10355 PyObject *resultobj = NULL;
10356 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10357 wxString *arg2 = 0 ;
10358 bool temp2 = false ;
10359 PyObject * obj0 = 0 ;
10360 PyObject * obj1 = 0 ;
10361 char *kwnames[] = {
10362 (char *) "self",(char *) "mimetype", NULL
10363 };
10364
10365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10367 if (SWIG_arg_fail(1)) SWIG_fail;
10368 {
10369 arg2 = wxString_in_helper(obj1);
10370 if (arg2 == NULL) SWIG_fail;
10371 temp2 = true;
10372 }
10373 {
10374 PyThreadState* __tstate = wxPyBeginAllowThreads();
10375 (arg1)->SetMimeType((wxString const &)*arg2);
10376
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 Py_INCREF(Py_None); resultobj = Py_None;
10381 {
10382 if (temp2)
10383 delete arg2;
10384 }
10385 return resultobj;
10386 fail:
10387 {
10388 if (temp2)
10389 delete arg2;
10390 }
10391 return NULL;
10392 }
10393
10394
10395 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10396 PyObject *obj;
10397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10398 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10399 Py_INCREF(obj);
10400 return Py_BuildValue((char *)"");
10401 }
10402 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10403 PyObject *resultobj = NULL;
10404 wxPyImageHandler *result;
10405 char *kwnames[] = {
10406 NULL
10407 };
10408
10409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 result = (wxPyImageHandler *)new wxPyImageHandler();
10413
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10418 return resultobj;
10419 fail:
10420 return NULL;
10421 }
10422
10423
10424 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10425 PyObject *resultobj = NULL;
10426 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10427 PyObject *arg2 = (PyObject *) 0 ;
10428 PyObject * obj0 = 0 ;
10429 PyObject * obj1 = 0 ;
10430 char *kwnames[] = {
10431 (char *) "self",(char *) "self", NULL
10432 };
10433
10434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10436 if (SWIG_arg_fail(1)) SWIG_fail;
10437 arg2 = obj1;
10438 {
10439 PyThreadState* __tstate = wxPyBeginAllowThreads();
10440 (arg1)->_SetSelf(arg2);
10441
10442 wxPyEndAllowThreads(__tstate);
10443 if (PyErr_Occurred()) SWIG_fail;
10444 }
10445 Py_INCREF(Py_None); resultobj = Py_None;
10446 return resultobj;
10447 fail:
10448 return NULL;
10449 }
10450
10451
10452 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10453 PyObject *obj;
10454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10455 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10456 Py_INCREF(obj);
10457 return Py_BuildValue((char *)"");
10458 }
10459 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10460 PyObject *resultobj = NULL;
10461 wxImageHistogram *result;
10462 char *kwnames[] = {
10463 NULL
10464 };
10465
10466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = (wxImageHistogram *)new wxImageHistogram();
10470
10471 wxPyEndAllowThreads(__tstate);
10472 if (PyErr_Occurred()) SWIG_fail;
10473 }
10474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10475 return resultobj;
10476 fail:
10477 return NULL;
10478 }
10479
10480
10481 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10482 PyObject *resultobj = NULL;
10483 byte arg1 ;
10484 byte arg2 ;
10485 byte arg3 ;
10486 unsigned long result;
10487 PyObject * obj0 = 0 ;
10488 PyObject * obj1 = 0 ;
10489 PyObject * obj2 = 0 ;
10490 char *kwnames[] = {
10491 (char *) "r",(char *) "g",(char *) "b", NULL
10492 };
10493
10494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10495 {
10496 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10497 if (SWIG_arg_fail(1)) SWIG_fail;
10498 }
10499 {
10500 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10501 if (SWIG_arg_fail(2)) SWIG_fail;
10502 }
10503 {
10504 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10505 if (SWIG_arg_fail(3)) SWIG_fail;
10506 }
10507 {
10508 PyThreadState* __tstate = wxPyBeginAllowThreads();
10509 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10510
10511 wxPyEndAllowThreads(__tstate);
10512 if (PyErr_Occurred()) SWIG_fail;
10513 }
10514 {
10515 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10516 }
10517 return resultobj;
10518 fail:
10519 return NULL;
10520 }
10521
10522
10523 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10524 PyObject *resultobj = NULL;
10525 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10526 byte *arg2 = (byte *) 0 ;
10527 byte *arg3 = (byte *) 0 ;
10528 byte *arg4 = (byte *) 0 ;
10529 byte arg5 = (byte) 1 ;
10530 byte arg6 = (byte) 0 ;
10531 byte arg7 = (byte) 0 ;
10532 bool result;
10533 byte temp2 ;
10534 int res2 = 0 ;
10535 byte temp3 ;
10536 int res3 = 0 ;
10537 byte temp4 ;
10538 int res4 = 0 ;
10539 PyObject * obj0 = 0 ;
10540 PyObject * obj1 = 0 ;
10541 PyObject * obj2 = 0 ;
10542 PyObject * obj3 = 0 ;
10543 char *kwnames[] = {
10544 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10545 };
10546
10547 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10548 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10549 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10552 if (SWIG_arg_fail(1)) SWIG_fail;
10553 if (obj1) {
10554 {
10555 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10556 if (SWIG_arg_fail(5)) SWIG_fail;
10557 }
10558 }
10559 if (obj2) {
10560 {
10561 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10562 if (SWIG_arg_fail(6)) SWIG_fail;
10563 }
10564 }
10565 if (obj3) {
10566 {
10567 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10568 if (SWIG_arg_fail(7)) SWIG_fail;
10569 }
10570 }
10571 {
10572 PyThreadState* __tstate = wxPyBeginAllowThreads();
10573 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10574
10575 wxPyEndAllowThreads(__tstate);
10576 if (PyErr_Occurred()) SWIG_fail;
10577 }
10578 {
10579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10580 }
10581 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10582 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10583 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10584 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10585 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10586 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10587 return resultobj;
10588 fail:
10589 return NULL;
10590 }
10591
10592
10593 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10594 PyObject *resultobj = NULL;
10595 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10596 unsigned long arg2 ;
10597 unsigned long result;
10598 PyObject * obj0 = 0 ;
10599 PyObject * obj1 = 0 ;
10600 char *kwnames[] = {
10601 (char *) "self",(char *) "key", NULL
10602 };
10603
10604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10606 if (SWIG_arg_fail(1)) SWIG_fail;
10607 {
10608 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10609 if (SWIG_arg_fail(2)) SWIG_fail;
10610 }
10611 {
10612 PyThreadState* __tstate = wxPyBeginAllowThreads();
10613 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10614
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10620 }
10621 return resultobj;
10622 fail:
10623 return NULL;
10624 }
10625
10626
10627 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10628 PyObject *resultobj = NULL;
10629 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10630 byte arg2 ;
10631 byte arg3 ;
10632 byte arg4 ;
10633 unsigned long result;
10634 PyObject * obj0 = 0 ;
10635 PyObject * obj1 = 0 ;
10636 PyObject * obj2 = 0 ;
10637 PyObject * obj3 = 0 ;
10638 char *kwnames[] = {
10639 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10640 };
10641
10642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10644 if (SWIG_arg_fail(1)) SWIG_fail;
10645 {
10646 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10647 if (SWIG_arg_fail(2)) SWIG_fail;
10648 }
10649 {
10650 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10651 if (SWIG_arg_fail(3)) SWIG_fail;
10652 }
10653 {
10654 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10655 if (SWIG_arg_fail(4)) SWIG_fail;
10656 }
10657 {
10658 PyThreadState* __tstate = wxPyBeginAllowThreads();
10659 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10660
10661 wxPyEndAllowThreads(__tstate);
10662 if (PyErr_Occurred()) SWIG_fail;
10663 }
10664 {
10665 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10666 }
10667 return resultobj;
10668 fail:
10669 return NULL;
10670 }
10671
10672
10673 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10674 PyObject *resultobj = NULL;
10675 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10676 wxColour *arg2 = 0 ;
10677 unsigned long result;
10678 wxColour temp2 ;
10679 PyObject * obj0 = 0 ;
10680 PyObject * obj1 = 0 ;
10681 char *kwnames[] = {
10682 (char *) "self",(char *) "colour", NULL
10683 };
10684
10685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10687 if (SWIG_arg_fail(1)) SWIG_fail;
10688 {
10689 arg2 = &temp2;
10690 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10691 }
10692 {
10693 PyThreadState* __tstate = wxPyBeginAllowThreads();
10694 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10695
10696 wxPyEndAllowThreads(__tstate);
10697 if (PyErr_Occurred()) SWIG_fail;
10698 }
10699 {
10700 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10701 }
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10709 PyObject *obj;
10710 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10711 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10712 Py_INCREF(obj);
10713 return Py_BuildValue((char *)"");
10714 }
10715 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10716 PyObject *resultobj = NULL;
10717 byte arg1 = (byte) 0 ;
10718 byte arg2 = (byte) 0 ;
10719 byte arg3 = (byte) 0 ;
10720 wxImage_RGBValue *result;
10721 PyObject * obj0 = 0 ;
10722 PyObject * obj1 = 0 ;
10723 PyObject * obj2 = 0 ;
10724 char *kwnames[] = {
10725 (char *) "r",(char *) "g",(char *) "b", NULL
10726 };
10727
10728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10729 if (obj0) {
10730 {
10731 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10732 if (SWIG_arg_fail(1)) SWIG_fail;
10733 }
10734 }
10735 if (obj1) {
10736 {
10737 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10738 if (SWIG_arg_fail(2)) SWIG_fail;
10739 }
10740 }
10741 if (obj2) {
10742 {
10743 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10744 if (SWIG_arg_fail(3)) SWIG_fail;
10745 }
10746 }
10747 {
10748 PyThreadState* __tstate = wxPyBeginAllowThreads();
10749 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10750
10751 wxPyEndAllowThreads(__tstate);
10752 if (PyErr_Occurred()) SWIG_fail;
10753 }
10754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10755 return resultobj;
10756 fail:
10757 return NULL;
10758 }
10759
10760
10761 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10762 PyObject *resultobj = NULL;
10763 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10764 byte arg2 ;
10765 PyObject * obj0 = 0 ;
10766 PyObject * obj1 = 0 ;
10767 char *kwnames[] = {
10768 (char *) "self",(char *) "red", NULL
10769 };
10770
10771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10773 if (SWIG_arg_fail(1)) SWIG_fail;
10774 {
10775 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10776 if (SWIG_arg_fail(2)) SWIG_fail;
10777 }
10778 if (arg1) (arg1)->red = arg2;
10779
10780 Py_INCREF(Py_None); resultobj = Py_None;
10781 return resultobj;
10782 fail:
10783 return NULL;
10784 }
10785
10786
10787 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10788 PyObject *resultobj = NULL;
10789 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10790 byte result;
10791 PyObject * obj0 = 0 ;
10792 char *kwnames[] = {
10793 (char *) "self", NULL
10794 };
10795
10796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10798 if (SWIG_arg_fail(1)) SWIG_fail;
10799 result = (byte) ((arg1)->red);
10800
10801 {
10802 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10803 }
10804 return resultobj;
10805 fail:
10806 return NULL;
10807 }
10808
10809
10810 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10811 PyObject *resultobj = NULL;
10812 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10813 byte arg2 ;
10814 PyObject * obj0 = 0 ;
10815 PyObject * obj1 = 0 ;
10816 char *kwnames[] = {
10817 (char *) "self",(char *) "green", NULL
10818 };
10819
10820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10822 if (SWIG_arg_fail(1)) SWIG_fail;
10823 {
10824 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10825 if (SWIG_arg_fail(2)) SWIG_fail;
10826 }
10827 if (arg1) (arg1)->green = arg2;
10828
10829 Py_INCREF(Py_None); resultobj = Py_None;
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj = NULL;
10838 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10839 byte result;
10840 PyObject * obj0 = 0 ;
10841 char *kwnames[] = {
10842 (char *) "self", NULL
10843 };
10844
10845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10847 if (SWIG_arg_fail(1)) SWIG_fail;
10848 result = (byte) ((arg1)->green);
10849
10850 {
10851 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10852 }
10853 return resultobj;
10854 fail:
10855 return NULL;
10856 }
10857
10858
10859 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10860 PyObject *resultobj = NULL;
10861 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10862 byte arg2 ;
10863 PyObject * obj0 = 0 ;
10864 PyObject * obj1 = 0 ;
10865 char *kwnames[] = {
10866 (char *) "self",(char *) "blue", NULL
10867 };
10868
10869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10871 if (SWIG_arg_fail(1)) SWIG_fail;
10872 {
10873 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10874 if (SWIG_arg_fail(2)) SWIG_fail;
10875 }
10876 if (arg1) (arg1)->blue = arg2;
10877
10878 Py_INCREF(Py_None); resultobj = Py_None;
10879 return resultobj;
10880 fail:
10881 return NULL;
10882 }
10883
10884
10885 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10886 PyObject *resultobj = NULL;
10887 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10888 byte result;
10889 PyObject * obj0 = 0 ;
10890 char *kwnames[] = {
10891 (char *) "self", NULL
10892 };
10893
10894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10896 if (SWIG_arg_fail(1)) SWIG_fail;
10897 result = (byte) ((arg1)->blue);
10898
10899 {
10900 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10901 }
10902 return resultobj;
10903 fail:
10904 return NULL;
10905 }
10906
10907
10908 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10909 PyObject *obj;
10910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10911 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10912 Py_INCREF(obj);
10913 return Py_BuildValue((char *)"");
10914 }
10915 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10916 PyObject *resultobj = NULL;
10917 double arg1 = (double) 0.0 ;
10918 double arg2 = (double) 0.0 ;
10919 double arg3 = (double) 0.0 ;
10920 wxImage_HSVValue *result;
10921 PyObject * obj0 = 0 ;
10922 PyObject * obj1 = 0 ;
10923 PyObject * obj2 = 0 ;
10924 char *kwnames[] = {
10925 (char *) "h",(char *) "s",(char *) "v", NULL
10926 };
10927
10928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10929 if (obj0) {
10930 {
10931 arg1 = static_cast<double >(SWIG_As_double(obj0));
10932 if (SWIG_arg_fail(1)) SWIG_fail;
10933 }
10934 }
10935 if (obj1) {
10936 {
10937 arg2 = static_cast<double >(SWIG_As_double(obj1));
10938 if (SWIG_arg_fail(2)) SWIG_fail;
10939 }
10940 }
10941 if (obj2) {
10942 {
10943 arg3 = static_cast<double >(SWIG_As_double(obj2));
10944 if (SWIG_arg_fail(3)) SWIG_fail;
10945 }
10946 }
10947 {
10948 PyThreadState* __tstate = wxPyBeginAllowThreads();
10949 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10950
10951 wxPyEndAllowThreads(__tstate);
10952 if (PyErr_Occurred()) SWIG_fail;
10953 }
10954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10955 return resultobj;
10956 fail:
10957 return NULL;
10958 }
10959
10960
10961 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10962 PyObject *resultobj = NULL;
10963 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10964 double arg2 ;
10965 PyObject * obj0 = 0 ;
10966 PyObject * obj1 = 0 ;
10967 char *kwnames[] = {
10968 (char *) "self",(char *) "hue", NULL
10969 };
10970
10971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10973 if (SWIG_arg_fail(1)) SWIG_fail;
10974 {
10975 arg2 = static_cast<double >(SWIG_As_double(obj1));
10976 if (SWIG_arg_fail(2)) SWIG_fail;
10977 }
10978 if (arg1) (arg1)->hue = arg2;
10979
10980 Py_INCREF(Py_None); resultobj = Py_None;
10981 return resultobj;
10982 fail:
10983 return NULL;
10984 }
10985
10986
10987 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10988 PyObject *resultobj = NULL;
10989 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10990 double result;
10991 PyObject * obj0 = 0 ;
10992 char *kwnames[] = {
10993 (char *) "self", NULL
10994 };
10995
10996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10998 if (SWIG_arg_fail(1)) SWIG_fail;
10999 result = (double) ((arg1)->hue);
11000
11001 {
11002 resultobj = SWIG_From_double(static_cast<double >(result));
11003 }
11004 return resultobj;
11005 fail:
11006 return NULL;
11007 }
11008
11009
11010 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
11011 PyObject *resultobj = NULL;
11012 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11013 double arg2 ;
11014 PyObject * obj0 = 0 ;
11015 PyObject * obj1 = 0 ;
11016 char *kwnames[] = {
11017 (char *) "self",(char *) "saturation", NULL
11018 };
11019
11020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
11021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11022 if (SWIG_arg_fail(1)) SWIG_fail;
11023 {
11024 arg2 = static_cast<double >(SWIG_As_double(obj1));
11025 if (SWIG_arg_fail(2)) SWIG_fail;
11026 }
11027 if (arg1) (arg1)->saturation = arg2;
11028
11029 Py_INCREF(Py_None); resultobj = Py_None;
11030 return resultobj;
11031 fail:
11032 return NULL;
11033 }
11034
11035
11036 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
11037 PyObject *resultobj = NULL;
11038 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11039 double result;
11040 PyObject * obj0 = 0 ;
11041 char *kwnames[] = {
11042 (char *) "self", NULL
11043 };
11044
11045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
11046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11047 if (SWIG_arg_fail(1)) SWIG_fail;
11048 result = (double) ((arg1)->saturation);
11049
11050 {
11051 resultobj = SWIG_From_double(static_cast<double >(result));
11052 }
11053 return resultobj;
11054 fail:
11055 return NULL;
11056 }
11057
11058
11059 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11060 PyObject *resultobj = NULL;
11061 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11062 double arg2 ;
11063 PyObject * obj0 = 0 ;
11064 PyObject * obj1 = 0 ;
11065 char *kwnames[] = {
11066 (char *) "self",(char *) "value", NULL
11067 };
11068
11069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11071 if (SWIG_arg_fail(1)) SWIG_fail;
11072 {
11073 arg2 = static_cast<double >(SWIG_As_double(obj1));
11074 if (SWIG_arg_fail(2)) SWIG_fail;
11075 }
11076 if (arg1) (arg1)->value = arg2;
11077
11078 Py_INCREF(Py_None); resultobj = Py_None;
11079 return resultobj;
11080 fail:
11081 return NULL;
11082 }
11083
11084
11085 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11086 PyObject *resultobj = NULL;
11087 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11088 double result;
11089 PyObject * obj0 = 0 ;
11090 char *kwnames[] = {
11091 (char *) "self", NULL
11092 };
11093
11094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11096 if (SWIG_arg_fail(1)) SWIG_fail;
11097 result = (double) ((arg1)->value);
11098
11099 {
11100 resultobj = SWIG_From_double(static_cast<double >(result));
11101 }
11102 return resultobj;
11103 fail:
11104 return NULL;
11105 }
11106
11107
11108 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11109 PyObject *obj;
11110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11111 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11112 Py_INCREF(obj);
11113 return Py_BuildValue((char *)"");
11114 }
11115 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11116 PyObject *resultobj = NULL;
11117 wxString *arg1 = 0 ;
11118 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11119 int arg3 = (int) -1 ;
11120 wxImage *result;
11121 bool temp1 = false ;
11122 PyObject * obj0 = 0 ;
11123 PyObject * obj1 = 0 ;
11124 PyObject * obj2 = 0 ;
11125 char *kwnames[] = {
11126 (char *) "name",(char *) "type",(char *) "index", NULL
11127 };
11128
11129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11130 {
11131 arg1 = wxString_in_helper(obj0);
11132 if (arg1 == NULL) SWIG_fail;
11133 temp1 = true;
11134 }
11135 if (obj1) {
11136 {
11137 arg2 = static_cast<long >(SWIG_As_long(obj1));
11138 if (SWIG_arg_fail(2)) SWIG_fail;
11139 }
11140 }
11141 if (obj2) {
11142 {
11143 arg3 = static_cast<int >(SWIG_As_int(obj2));
11144 if (SWIG_arg_fail(3)) SWIG_fail;
11145 }
11146 }
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11150
11151 wxPyEndAllowThreads(__tstate);
11152 if (PyErr_Occurred()) SWIG_fail;
11153 }
11154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11155 {
11156 if (temp1)
11157 delete arg1;
11158 }
11159 return resultobj;
11160 fail:
11161 {
11162 if (temp1)
11163 delete arg1;
11164 }
11165 return NULL;
11166 }
11167
11168
11169 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11170 PyObject *resultobj = NULL;
11171 wxImage *arg1 = (wxImage *) 0 ;
11172 PyObject * obj0 = 0 ;
11173 char *kwnames[] = {
11174 (char *) "self", NULL
11175 };
11176
11177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11179 if (SWIG_arg_fail(1)) SWIG_fail;
11180 {
11181 PyThreadState* __tstate = wxPyBeginAllowThreads();
11182 delete arg1;
11183
11184 wxPyEndAllowThreads(__tstate);
11185 if (PyErr_Occurred()) SWIG_fail;
11186 }
11187 Py_INCREF(Py_None); resultobj = Py_None;
11188 return resultobj;
11189 fail:
11190 return NULL;
11191 }
11192
11193
11194 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11195 PyObject *resultobj = NULL;
11196 wxString *arg1 = 0 ;
11197 wxString *arg2 = 0 ;
11198 int arg3 = (int) -1 ;
11199 wxImage *result;
11200 bool temp1 = false ;
11201 bool temp2 = false ;
11202 PyObject * obj0 = 0 ;
11203 PyObject * obj1 = 0 ;
11204 PyObject * obj2 = 0 ;
11205 char *kwnames[] = {
11206 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11207 };
11208
11209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11210 {
11211 arg1 = wxString_in_helper(obj0);
11212 if (arg1 == NULL) SWIG_fail;
11213 temp1 = true;
11214 }
11215 {
11216 arg2 = wxString_in_helper(obj1);
11217 if (arg2 == NULL) SWIG_fail;
11218 temp2 = true;
11219 }
11220 if (obj2) {
11221 {
11222 arg3 = static_cast<int >(SWIG_As_int(obj2));
11223 if (SWIG_arg_fail(3)) SWIG_fail;
11224 }
11225 }
11226 {
11227 PyThreadState* __tstate = wxPyBeginAllowThreads();
11228 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11229
11230 wxPyEndAllowThreads(__tstate);
11231 if (PyErr_Occurred()) SWIG_fail;
11232 }
11233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11234 {
11235 if (temp1)
11236 delete arg1;
11237 }
11238 {
11239 if (temp2)
11240 delete arg2;
11241 }
11242 return resultobj;
11243 fail:
11244 {
11245 if (temp1)
11246 delete arg1;
11247 }
11248 {
11249 if (temp2)
11250 delete arg2;
11251 }
11252 return NULL;
11253 }
11254
11255
11256 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj = NULL;
11258 wxInputStream *arg1 = 0 ;
11259 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11260 int arg3 = (int) -1 ;
11261 wxImage *result;
11262 wxPyInputStream *temp1 ;
11263 bool created1 ;
11264 PyObject * obj0 = 0 ;
11265 PyObject * obj1 = 0 ;
11266 PyObject * obj2 = 0 ;
11267 char *kwnames[] = {
11268 (char *) "stream",(char *) "type",(char *) "index", NULL
11269 };
11270
11271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11272 {
11273 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11274 arg1 = temp1->m_wxis;
11275 created1 = false;
11276 } else {
11277 PyErr_Clear(); // clear the failure of the wxPyConvert above
11278 arg1 = wxPyCBInputStream_create(obj0, false);
11279 if (arg1 == NULL) {
11280 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11281 SWIG_fail;
11282 }
11283 created1 = true;
11284 }
11285 }
11286 if (obj1) {
11287 {
11288 arg2 = static_cast<long >(SWIG_As_long(obj1));
11289 if (SWIG_arg_fail(2)) SWIG_fail;
11290 }
11291 }
11292 if (obj2) {
11293 {
11294 arg3 = static_cast<int >(SWIG_As_int(obj2));
11295 if (SWIG_arg_fail(3)) SWIG_fail;
11296 }
11297 }
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11301
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11306 {
11307 if (created1) delete arg1;
11308 }
11309 return resultobj;
11310 fail:
11311 {
11312 if (created1) delete arg1;
11313 }
11314 return NULL;
11315 }
11316
11317
11318 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11319 PyObject *resultobj = NULL;
11320 wxInputStream *arg1 = 0 ;
11321 wxString *arg2 = 0 ;
11322 int arg3 = (int) -1 ;
11323 wxImage *result;
11324 wxPyInputStream *temp1 ;
11325 bool created1 ;
11326 bool temp2 = false ;
11327 PyObject * obj0 = 0 ;
11328 PyObject * obj1 = 0 ;
11329 PyObject * obj2 = 0 ;
11330 char *kwnames[] = {
11331 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11332 };
11333
11334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11335 {
11336 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11337 arg1 = temp1->m_wxis;
11338 created1 = false;
11339 } else {
11340 PyErr_Clear(); // clear the failure of the wxPyConvert above
11341 arg1 = wxPyCBInputStream_create(obj0, false);
11342 if (arg1 == NULL) {
11343 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11344 SWIG_fail;
11345 }
11346 created1 = true;
11347 }
11348 }
11349 {
11350 arg2 = wxString_in_helper(obj1);
11351 if (arg2 == NULL) SWIG_fail;
11352 temp2 = true;
11353 }
11354 if (obj2) {
11355 {
11356 arg3 = static_cast<int >(SWIG_As_int(obj2));
11357 if (SWIG_arg_fail(3)) SWIG_fail;
11358 }
11359 }
11360 {
11361 PyThreadState* __tstate = wxPyBeginAllowThreads();
11362 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11363
11364 wxPyEndAllowThreads(__tstate);
11365 if (PyErr_Occurred()) SWIG_fail;
11366 }
11367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11368 {
11369 if (created1) delete arg1;
11370 }
11371 {
11372 if (temp2)
11373 delete arg2;
11374 }
11375 return resultobj;
11376 fail:
11377 {
11378 if (created1) delete arg1;
11379 }
11380 {
11381 if (temp2)
11382 delete arg2;
11383 }
11384 return NULL;
11385 }
11386
11387
11388 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11389 PyObject *resultobj = NULL;
11390 int arg1 = (int) 0 ;
11391 int arg2 = (int) 0 ;
11392 bool arg3 = (bool) true ;
11393 wxImage *result;
11394 PyObject * obj0 = 0 ;
11395 PyObject * obj1 = 0 ;
11396 PyObject * obj2 = 0 ;
11397 char *kwnames[] = {
11398 (char *) "width",(char *) "height",(char *) "clear", NULL
11399 };
11400
11401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11402 if (obj0) {
11403 {
11404 arg1 = static_cast<int >(SWIG_As_int(obj0));
11405 if (SWIG_arg_fail(1)) SWIG_fail;
11406 }
11407 }
11408 if (obj1) {
11409 {
11410 arg2 = static_cast<int >(SWIG_As_int(obj1));
11411 if (SWIG_arg_fail(2)) SWIG_fail;
11412 }
11413 }
11414 if (obj2) {
11415 {
11416 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11417 if (SWIG_arg_fail(3)) SWIG_fail;
11418 }
11419 }
11420 {
11421 PyThreadState* __tstate = wxPyBeginAllowThreads();
11422 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11423
11424 wxPyEndAllowThreads(__tstate);
11425 if (PyErr_Occurred()) SWIG_fail;
11426 }
11427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11428 return resultobj;
11429 fail:
11430 return NULL;
11431 }
11432
11433
11434 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11435 PyObject *resultobj = NULL;
11436 wxBitmap *arg1 = 0 ;
11437 wxImage *result;
11438 PyObject * obj0 = 0 ;
11439 char *kwnames[] = {
11440 (char *) "bitmap", NULL
11441 };
11442
11443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11444 {
11445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11446 if (SWIG_arg_fail(1)) SWIG_fail;
11447 if (arg1 == NULL) {
11448 SWIG_null_ref("wxBitmap");
11449 }
11450 if (SWIG_arg_fail(1)) SWIG_fail;
11451 }
11452 {
11453 if (!wxPyCheckForApp()) SWIG_fail;
11454 PyThreadState* __tstate = wxPyBeginAllowThreads();
11455 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11456
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11461 return resultobj;
11462 fail:
11463 return NULL;
11464 }
11465
11466
11467 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11468 PyObject *resultobj = NULL;
11469 int arg1 ;
11470 int arg2 ;
11471 buffer arg3 ;
11472 int arg4 ;
11473 wxImage *result;
11474 PyObject * obj0 = 0 ;
11475 PyObject * obj1 = 0 ;
11476 PyObject * obj2 = 0 ;
11477 char *kwnames[] = {
11478 (char *) "width",(char *) "height",(char *) "data", NULL
11479 };
11480
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11482 {
11483 arg1 = static_cast<int >(SWIG_As_int(obj0));
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 }
11486 {
11487 arg2 = static_cast<int >(SWIG_As_int(obj1));
11488 if (SWIG_arg_fail(2)) SWIG_fail;
11489 }
11490 {
11491 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11492 }
11493 {
11494 PyThreadState* __tstate = wxPyBeginAllowThreads();
11495 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11496
11497 wxPyEndAllowThreads(__tstate);
11498 if (PyErr_Occurred()) SWIG_fail;
11499 }
11500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11501 return resultobj;
11502 fail:
11503 return NULL;
11504 }
11505
11506
11507 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj = NULL;
11509 int arg1 ;
11510 int arg2 ;
11511 buffer arg3 ;
11512 int arg4 ;
11513 buffer arg5 ;
11514 int arg6 ;
11515 wxImage *result;
11516 PyObject * obj0 = 0 ;
11517 PyObject * obj1 = 0 ;
11518 PyObject * obj2 = 0 ;
11519 PyObject * obj3 = 0 ;
11520 char *kwnames[] = {
11521 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11522 };
11523
11524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11525 {
11526 arg1 = static_cast<int >(SWIG_As_int(obj0));
11527 if (SWIG_arg_fail(1)) SWIG_fail;
11528 }
11529 {
11530 arg2 = static_cast<int >(SWIG_As_int(obj1));
11531 if (SWIG_arg_fail(2)) SWIG_fail;
11532 }
11533 {
11534 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11535 }
11536 {
11537 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11538 }
11539 {
11540 PyThreadState* __tstate = wxPyBeginAllowThreads();
11541 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11542
11543 wxPyEndAllowThreads(__tstate);
11544 if (PyErr_Occurred()) SWIG_fail;
11545 }
11546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11547 return resultobj;
11548 fail:
11549 return NULL;
11550 }
11551
11552
11553 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11554 PyObject *resultobj = NULL;
11555 wxImage *arg1 = (wxImage *) 0 ;
11556 int arg2 ;
11557 int arg3 ;
11558 bool arg4 = (bool) true ;
11559 PyObject * obj0 = 0 ;
11560 PyObject * obj1 = 0 ;
11561 PyObject * obj2 = 0 ;
11562 PyObject * obj3 = 0 ;
11563 char *kwnames[] = {
11564 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11565 };
11566
11567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11569 if (SWIG_arg_fail(1)) SWIG_fail;
11570 {
11571 arg2 = static_cast<int >(SWIG_As_int(obj1));
11572 if (SWIG_arg_fail(2)) SWIG_fail;
11573 }
11574 {
11575 arg3 = static_cast<int >(SWIG_As_int(obj2));
11576 if (SWIG_arg_fail(3)) SWIG_fail;
11577 }
11578 if (obj3) {
11579 {
11580 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11581 if (SWIG_arg_fail(4)) SWIG_fail;
11582 }
11583 }
11584 {
11585 PyThreadState* __tstate = wxPyBeginAllowThreads();
11586 (arg1)->Create(arg2,arg3,arg4);
11587
11588 wxPyEndAllowThreads(__tstate);
11589 if (PyErr_Occurred()) SWIG_fail;
11590 }
11591 Py_INCREF(Py_None); resultobj = Py_None;
11592 return resultobj;
11593 fail:
11594 return NULL;
11595 }
11596
11597
11598 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11599 PyObject *resultobj = NULL;
11600 wxImage *arg1 = (wxImage *) 0 ;
11601 PyObject * obj0 = 0 ;
11602 char *kwnames[] = {
11603 (char *) "self", NULL
11604 };
11605
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11608 if (SWIG_arg_fail(1)) SWIG_fail;
11609 {
11610 PyThreadState* __tstate = wxPyBeginAllowThreads();
11611 (arg1)->Destroy();
11612
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 Py_INCREF(Py_None); resultobj = Py_None;
11617 return resultobj;
11618 fail:
11619 return NULL;
11620 }
11621
11622
11623 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11624 PyObject *resultobj = NULL;
11625 wxImage *arg1 = (wxImage *) 0 ;
11626 int arg2 ;
11627 int arg3 ;
11628 SwigValueWrapper<wxImage > result;
11629 PyObject * obj0 = 0 ;
11630 PyObject * obj1 = 0 ;
11631 PyObject * obj2 = 0 ;
11632 char *kwnames[] = {
11633 (char *) "self",(char *) "width",(char *) "height", NULL
11634 };
11635
11636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11638 if (SWIG_arg_fail(1)) SWIG_fail;
11639 {
11640 arg2 = static_cast<int >(SWIG_As_int(obj1));
11641 if (SWIG_arg_fail(2)) SWIG_fail;
11642 }
11643 {
11644 arg3 = static_cast<int >(SWIG_As_int(obj2));
11645 if (SWIG_arg_fail(3)) SWIG_fail;
11646 }
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 result = (arg1)->Scale(arg2,arg3);
11650
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 {
11655 wxImage * resultptr;
11656 resultptr = new wxImage(static_cast<wxImage & >(result));
11657 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11658 }
11659 return resultobj;
11660 fail:
11661 return NULL;
11662 }
11663
11664
11665 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11666 PyObject *resultobj = NULL;
11667 wxImage *arg1 = (wxImage *) 0 ;
11668 int arg2 ;
11669 int arg3 ;
11670 SwigValueWrapper<wxImage > result;
11671 PyObject * obj0 = 0 ;
11672 PyObject * obj1 = 0 ;
11673 PyObject * obj2 = 0 ;
11674 char *kwnames[] = {
11675 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11676 };
11677
11678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11680 if (SWIG_arg_fail(1)) SWIG_fail;
11681 {
11682 arg2 = static_cast<int >(SWIG_As_int(obj1));
11683 if (SWIG_arg_fail(2)) SWIG_fail;
11684 }
11685 {
11686 arg3 = static_cast<int >(SWIG_As_int(obj2));
11687 if (SWIG_arg_fail(3)) SWIG_fail;
11688 }
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11692
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 {
11697 wxImage * resultptr;
11698 resultptr = new wxImage(static_cast<wxImage & >(result));
11699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11700 }
11701 return resultobj;
11702 fail:
11703 return NULL;
11704 }
11705
11706
11707 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11708 PyObject *resultobj = NULL;
11709 wxImage *arg1 = (wxImage *) 0 ;
11710 int arg2 ;
11711 int arg3 ;
11712 wxImage *result;
11713 PyObject * obj0 = 0 ;
11714 PyObject * obj1 = 0 ;
11715 PyObject * obj2 = 0 ;
11716 char *kwnames[] = {
11717 (char *) "self",(char *) "width",(char *) "height", NULL
11718 };
11719
11720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11722 if (SWIG_arg_fail(1)) SWIG_fail;
11723 {
11724 arg2 = static_cast<int >(SWIG_As_int(obj1));
11725 if (SWIG_arg_fail(2)) SWIG_fail;
11726 }
11727 {
11728 arg3 = static_cast<int >(SWIG_As_int(obj2));
11729 if (SWIG_arg_fail(3)) SWIG_fail;
11730 }
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 {
11734 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11735 result = (wxImage *) &_result_ref;
11736 }
11737
11738 wxPyEndAllowThreads(__tstate);
11739 if (PyErr_Occurred()) SWIG_fail;
11740 }
11741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11742 return resultobj;
11743 fail:
11744 return NULL;
11745 }
11746
11747
11748 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11749 PyObject *resultobj = NULL;
11750 wxImage *arg1 = (wxImage *) 0 ;
11751 wxSize *arg2 = 0 ;
11752 wxPoint *arg3 = 0 ;
11753 int arg4 = (int) -1 ;
11754 int arg5 = (int) -1 ;
11755 int arg6 = (int) -1 ;
11756 wxImage *result;
11757 wxSize temp2 ;
11758 wxPoint temp3 ;
11759 PyObject * obj0 = 0 ;
11760 PyObject * obj1 = 0 ;
11761 PyObject * obj2 = 0 ;
11762 PyObject * obj3 = 0 ;
11763 PyObject * obj4 = 0 ;
11764 PyObject * obj5 = 0 ;
11765 char *kwnames[] = {
11766 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11767 };
11768
11769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11771 if (SWIG_arg_fail(1)) SWIG_fail;
11772 {
11773 arg2 = &temp2;
11774 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11775 }
11776 {
11777 arg3 = &temp3;
11778 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11779 }
11780 if (obj3) {
11781 {
11782 arg4 = static_cast<int >(SWIG_As_int(obj3));
11783 if (SWIG_arg_fail(4)) SWIG_fail;
11784 }
11785 }
11786 if (obj4) {
11787 {
11788 arg5 = static_cast<int >(SWIG_As_int(obj4));
11789 if (SWIG_arg_fail(5)) SWIG_fail;
11790 }
11791 }
11792 if (obj5) {
11793 {
11794 arg6 = static_cast<int >(SWIG_As_int(obj5));
11795 if (SWIG_arg_fail(6)) SWIG_fail;
11796 }
11797 }
11798 {
11799 PyThreadState* __tstate = wxPyBeginAllowThreads();
11800 {
11801 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11802 result = (wxImage *) &_result_ref;
11803 }
11804
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11816 PyObject *resultobj = NULL;
11817 wxImage *arg1 = (wxImage *) 0 ;
11818 int arg2 ;
11819 int arg3 ;
11820 byte arg4 ;
11821 byte arg5 ;
11822 byte arg6 ;
11823 PyObject * obj0 = 0 ;
11824 PyObject * obj1 = 0 ;
11825 PyObject * obj2 = 0 ;
11826 PyObject * obj3 = 0 ;
11827 PyObject * obj4 = 0 ;
11828 PyObject * obj5 = 0 ;
11829 char *kwnames[] = {
11830 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11831 };
11832
11833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11835 if (SWIG_arg_fail(1)) SWIG_fail;
11836 {
11837 arg2 = static_cast<int >(SWIG_As_int(obj1));
11838 if (SWIG_arg_fail(2)) SWIG_fail;
11839 }
11840 {
11841 arg3 = static_cast<int >(SWIG_As_int(obj2));
11842 if (SWIG_arg_fail(3)) SWIG_fail;
11843 }
11844 {
11845 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11846 if (SWIG_arg_fail(4)) SWIG_fail;
11847 }
11848 {
11849 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11850 if (SWIG_arg_fail(5)) SWIG_fail;
11851 }
11852 {
11853 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11854 if (SWIG_arg_fail(6)) SWIG_fail;
11855 }
11856 {
11857 PyThreadState* __tstate = wxPyBeginAllowThreads();
11858 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11859
11860 wxPyEndAllowThreads(__tstate);
11861 if (PyErr_Occurred()) SWIG_fail;
11862 }
11863 Py_INCREF(Py_None); resultobj = Py_None;
11864 return resultobj;
11865 fail:
11866 return NULL;
11867 }
11868
11869
11870 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11871 PyObject *resultobj = NULL;
11872 wxImage *arg1 = (wxImage *) 0 ;
11873 wxRect *arg2 = 0 ;
11874 byte arg3 ;
11875 byte arg4 ;
11876 byte arg5 ;
11877 wxRect temp2 ;
11878 PyObject * obj0 = 0 ;
11879 PyObject * obj1 = 0 ;
11880 PyObject * obj2 = 0 ;
11881 PyObject * obj3 = 0 ;
11882 PyObject * obj4 = 0 ;
11883 char *kwnames[] = {
11884 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11885 };
11886
11887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11889 if (SWIG_arg_fail(1)) SWIG_fail;
11890 {
11891 arg2 = &temp2;
11892 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11893 }
11894 {
11895 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11896 if (SWIG_arg_fail(3)) SWIG_fail;
11897 }
11898 {
11899 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11900 if (SWIG_arg_fail(4)) SWIG_fail;
11901 }
11902 {
11903 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11904 if (SWIG_arg_fail(5)) SWIG_fail;
11905 }
11906 {
11907 PyThreadState* __tstate = wxPyBeginAllowThreads();
11908 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11909
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 Py_INCREF(Py_None); resultobj = Py_None;
11914 return resultobj;
11915 fail:
11916 return NULL;
11917 }
11918
11919
11920 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11921 PyObject *resultobj = NULL;
11922 wxImage *arg1 = (wxImage *) 0 ;
11923 int arg2 ;
11924 int arg3 ;
11925 byte result;
11926 PyObject * obj0 = 0 ;
11927 PyObject * obj1 = 0 ;
11928 PyObject * obj2 = 0 ;
11929 char *kwnames[] = {
11930 (char *) "self",(char *) "x",(char *) "y", NULL
11931 };
11932
11933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11935 if (SWIG_arg_fail(1)) SWIG_fail;
11936 {
11937 arg2 = static_cast<int >(SWIG_As_int(obj1));
11938 if (SWIG_arg_fail(2)) SWIG_fail;
11939 }
11940 {
11941 arg3 = static_cast<int >(SWIG_As_int(obj2));
11942 if (SWIG_arg_fail(3)) SWIG_fail;
11943 }
11944 {
11945 PyThreadState* __tstate = wxPyBeginAllowThreads();
11946 result = (byte)(arg1)->GetRed(arg2,arg3);
11947
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 {
11952 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11953 }
11954 return resultobj;
11955 fail:
11956 return NULL;
11957 }
11958
11959
11960 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11961 PyObject *resultobj = NULL;
11962 wxImage *arg1 = (wxImage *) 0 ;
11963 int arg2 ;
11964 int arg3 ;
11965 byte result;
11966 PyObject * obj0 = 0 ;
11967 PyObject * obj1 = 0 ;
11968 PyObject * obj2 = 0 ;
11969 char *kwnames[] = {
11970 (char *) "self",(char *) "x",(char *) "y", NULL
11971 };
11972
11973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11975 if (SWIG_arg_fail(1)) SWIG_fail;
11976 {
11977 arg2 = static_cast<int >(SWIG_As_int(obj1));
11978 if (SWIG_arg_fail(2)) SWIG_fail;
11979 }
11980 {
11981 arg3 = static_cast<int >(SWIG_As_int(obj2));
11982 if (SWIG_arg_fail(3)) SWIG_fail;
11983 }
11984 {
11985 PyThreadState* __tstate = wxPyBeginAllowThreads();
11986 result = (byte)(arg1)->GetGreen(arg2,arg3);
11987
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 {
11992 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11993 }
11994 return resultobj;
11995 fail:
11996 return NULL;
11997 }
11998
11999
12000 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12001 PyObject *resultobj = NULL;
12002 wxImage *arg1 = (wxImage *) 0 ;
12003 int arg2 ;
12004 int arg3 ;
12005 byte result;
12006 PyObject * obj0 = 0 ;
12007 PyObject * obj1 = 0 ;
12008 PyObject * obj2 = 0 ;
12009 char *kwnames[] = {
12010 (char *) "self",(char *) "x",(char *) "y", NULL
12011 };
12012
12013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
12014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12015 if (SWIG_arg_fail(1)) SWIG_fail;
12016 {
12017 arg2 = static_cast<int >(SWIG_As_int(obj1));
12018 if (SWIG_arg_fail(2)) SWIG_fail;
12019 }
12020 {
12021 arg3 = static_cast<int >(SWIG_As_int(obj2));
12022 if (SWIG_arg_fail(3)) SWIG_fail;
12023 }
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 result = (byte)(arg1)->GetBlue(arg2,arg3);
12027
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 {
12032 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12033 }
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = NULL;
12042 wxImage *arg1 = (wxImage *) 0 ;
12043 int arg2 ;
12044 int arg3 ;
12045 byte arg4 ;
12046 PyObject * obj0 = 0 ;
12047 PyObject * obj1 = 0 ;
12048 PyObject * obj2 = 0 ;
12049 PyObject * obj3 = 0 ;
12050 char *kwnames[] = {
12051 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
12052 };
12053
12054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12056 if (SWIG_arg_fail(1)) SWIG_fail;
12057 {
12058 arg2 = static_cast<int >(SWIG_As_int(obj1));
12059 if (SWIG_arg_fail(2)) SWIG_fail;
12060 }
12061 {
12062 arg3 = static_cast<int >(SWIG_As_int(obj2));
12063 if (SWIG_arg_fail(3)) SWIG_fail;
12064 }
12065 {
12066 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12067 if (SWIG_arg_fail(4)) SWIG_fail;
12068 }
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 (arg1)->SetAlpha(arg2,arg3,arg4);
12072
12073 wxPyEndAllowThreads(__tstate);
12074 if (PyErr_Occurred()) SWIG_fail;
12075 }
12076 Py_INCREF(Py_None); resultobj = Py_None;
12077 return resultobj;
12078 fail:
12079 return NULL;
12080 }
12081
12082
12083 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12084 PyObject *resultobj = NULL;
12085 wxImage *arg1 = (wxImage *) 0 ;
12086 int arg2 ;
12087 int arg3 ;
12088 byte result;
12089 PyObject * obj0 = 0 ;
12090 PyObject * obj1 = 0 ;
12091 PyObject * obj2 = 0 ;
12092 char *kwnames[] = {
12093 (char *) "self",(char *) "x",(char *) "y", NULL
12094 };
12095
12096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12098 if (SWIG_arg_fail(1)) SWIG_fail;
12099 {
12100 arg2 = static_cast<int >(SWIG_As_int(obj1));
12101 if (SWIG_arg_fail(2)) SWIG_fail;
12102 }
12103 {
12104 arg3 = static_cast<int >(SWIG_As_int(obj2));
12105 if (SWIG_arg_fail(3)) SWIG_fail;
12106 }
12107 {
12108 PyThreadState* __tstate = wxPyBeginAllowThreads();
12109 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12110
12111 wxPyEndAllowThreads(__tstate);
12112 if (PyErr_Occurred()) SWIG_fail;
12113 }
12114 {
12115 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12116 }
12117 return resultobj;
12118 fail:
12119 return NULL;
12120 }
12121
12122
12123 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12124 PyObject *resultobj = NULL;
12125 wxImage *arg1 = (wxImage *) 0 ;
12126 bool result;
12127 PyObject * obj0 = 0 ;
12128 char *kwnames[] = {
12129 (char *) "self", NULL
12130 };
12131
12132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12134 if (SWIG_arg_fail(1)) SWIG_fail;
12135 {
12136 PyThreadState* __tstate = wxPyBeginAllowThreads();
12137 result = (bool)(arg1)->HasAlpha();
12138
12139 wxPyEndAllowThreads(__tstate);
12140 if (PyErr_Occurred()) SWIG_fail;
12141 }
12142 {
12143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12144 }
12145 return resultobj;
12146 fail:
12147 return NULL;
12148 }
12149
12150
12151 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12152 PyObject *resultobj = NULL;
12153 wxImage *arg1 = (wxImage *) 0 ;
12154 PyObject * obj0 = 0 ;
12155 char *kwnames[] = {
12156 (char *) "self", NULL
12157 };
12158
12159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12161 if (SWIG_arg_fail(1)) SWIG_fail;
12162 {
12163 PyThreadState* __tstate = wxPyBeginAllowThreads();
12164 (arg1)->InitAlpha();
12165
12166 wxPyEndAllowThreads(__tstate);
12167 if (PyErr_Occurred()) SWIG_fail;
12168 }
12169 Py_INCREF(Py_None); resultobj = Py_None;
12170 return resultobj;
12171 fail:
12172 return NULL;
12173 }
12174
12175
12176 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12177 PyObject *resultobj = NULL;
12178 wxImage *arg1 = (wxImage *) 0 ;
12179 int arg2 ;
12180 int arg3 ;
12181 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12182 bool result;
12183 PyObject * obj0 = 0 ;
12184 PyObject * obj1 = 0 ;
12185 PyObject * obj2 = 0 ;
12186 PyObject * obj3 = 0 ;
12187 char *kwnames[] = {
12188 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12189 };
12190
12191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12193 if (SWIG_arg_fail(1)) SWIG_fail;
12194 {
12195 arg2 = static_cast<int >(SWIG_As_int(obj1));
12196 if (SWIG_arg_fail(2)) SWIG_fail;
12197 }
12198 {
12199 arg3 = static_cast<int >(SWIG_As_int(obj2));
12200 if (SWIG_arg_fail(3)) SWIG_fail;
12201 }
12202 if (obj3) {
12203 {
12204 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12205 if (SWIG_arg_fail(4)) SWIG_fail;
12206 }
12207 }
12208 {
12209 PyThreadState* __tstate = wxPyBeginAllowThreads();
12210 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12211
12212 wxPyEndAllowThreads(__tstate);
12213 if (PyErr_Occurred()) SWIG_fail;
12214 }
12215 {
12216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12217 }
12218 return resultobj;
12219 fail:
12220 return NULL;
12221 }
12222
12223
12224 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12225 PyObject *resultobj = NULL;
12226 wxImage *arg1 = (wxImage *) 0 ;
12227 byte *arg2 = (byte *) 0 ;
12228 byte *arg3 = (byte *) 0 ;
12229 byte *arg4 = (byte *) 0 ;
12230 byte arg5 = (byte) 0 ;
12231 byte arg6 = (byte) 0 ;
12232 byte arg7 = (byte) 0 ;
12233 bool result;
12234 byte temp2 ;
12235 int res2 = 0 ;
12236 byte temp3 ;
12237 int res3 = 0 ;
12238 byte temp4 ;
12239 int res4 = 0 ;
12240 PyObject * obj0 = 0 ;
12241 PyObject * obj1 = 0 ;
12242 PyObject * obj2 = 0 ;
12243 PyObject * obj3 = 0 ;
12244 char *kwnames[] = {
12245 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12246 };
12247
12248 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12249 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12250 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12253 if (SWIG_arg_fail(1)) SWIG_fail;
12254 if (obj1) {
12255 {
12256 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12257 if (SWIG_arg_fail(5)) SWIG_fail;
12258 }
12259 }
12260 if (obj2) {
12261 {
12262 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12263 if (SWIG_arg_fail(6)) SWIG_fail;
12264 }
12265 }
12266 if (obj3) {
12267 {
12268 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12269 if (SWIG_arg_fail(7)) SWIG_fail;
12270 }
12271 }
12272 {
12273 PyThreadState* __tstate = wxPyBeginAllowThreads();
12274 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12275
12276 wxPyEndAllowThreads(__tstate);
12277 if (PyErr_Occurred()) SWIG_fail;
12278 }
12279 {
12280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12281 }
12282 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12283 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12284 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12285 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12286 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12287 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12288 return resultobj;
12289 fail:
12290 return NULL;
12291 }
12292
12293
12294 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12295 PyObject *resultobj = NULL;
12296 wxImage *arg1 = (wxImage *) 0 ;
12297 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12298 bool result;
12299 PyObject * obj0 = 0 ;
12300 PyObject * obj1 = 0 ;
12301 char *kwnames[] = {
12302 (char *) "self",(char *) "threshold", NULL
12303 };
12304
12305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12307 if (SWIG_arg_fail(1)) SWIG_fail;
12308 if (obj1) {
12309 {
12310 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12311 if (SWIG_arg_fail(2)) SWIG_fail;
12312 }
12313 }
12314 {
12315 PyThreadState* __tstate = wxPyBeginAllowThreads();
12316 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12317
12318 wxPyEndAllowThreads(__tstate);
12319 if (PyErr_Occurred()) SWIG_fail;
12320 }
12321 {
12322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12323 }
12324 return resultobj;
12325 fail:
12326 return NULL;
12327 }
12328
12329
12330 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12331 PyObject *resultobj = NULL;
12332 wxImage *arg1 = (wxImage *) 0 ;
12333 byte arg2 ;
12334 byte arg3 ;
12335 byte arg4 ;
12336 bool result;
12337 PyObject * obj0 = 0 ;
12338 PyObject * obj1 = 0 ;
12339 PyObject * obj2 = 0 ;
12340 PyObject * obj3 = 0 ;
12341 char *kwnames[] = {
12342 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12343 };
12344
12345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12347 if (SWIG_arg_fail(1)) SWIG_fail;
12348 {
12349 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12350 if (SWIG_arg_fail(2)) SWIG_fail;
12351 }
12352 {
12353 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12354 if (SWIG_arg_fail(3)) SWIG_fail;
12355 }
12356 {
12357 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12358 if (SWIG_arg_fail(4)) SWIG_fail;
12359 }
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12369 }
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj = NULL;
12378 wxImage *arg1 = (wxImage *) 0 ;
12379 wxImage *arg2 = 0 ;
12380 byte arg3 ;
12381 byte arg4 ;
12382 byte arg5 ;
12383 bool result;
12384 PyObject * obj0 = 0 ;
12385 PyObject * obj1 = 0 ;
12386 PyObject * obj2 = 0 ;
12387 PyObject * obj3 = 0 ;
12388 PyObject * obj4 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 {
12397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12398 if (SWIG_arg_fail(2)) SWIG_fail;
12399 if (arg2 == NULL) {
12400 SWIG_null_ref("wxImage");
12401 }
12402 if (SWIG_arg_fail(2)) SWIG_fail;
12403 }
12404 {
12405 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12406 if (SWIG_arg_fail(3)) SWIG_fail;
12407 }
12408 {
12409 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12410 if (SWIG_arg_fail(4)) SWIG_fail;
12411 }
12412 {
12413 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12414 if (SWIG_arg_fail(5)) SWIG_fail;
12415 }
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12419
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 {
12424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12425 }
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj = NULL;
12434 wxString *arg1 = 0 ;
12435 bool result;
12436 bool temp1 = false ;
12437 PyObject * obj0 = 0 ;
12438 char *kwnames[] = {
12439 (char *) "filename", NULL
12440 };
12441
12442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12443 {
12444 arg1 = wxString_in_helper(obj0);
12445 if (arg1 == NULL) SWIG_fail;
12446 temp1 = true;
12447 }
12448 {
12449 PyThreadState* __tstate = wxPyBeginAllowThreads();
12450 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12451
12452 wxPyEndAllowThreads(__tstate);
12453 if (PyErr_Occurred()) SWIG_fail;
12454 }
12455 {
12456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12457 }
12458 {
12459 if (temp1)
12460 delete arg1;
12461 }
12462 return resultobj;
12463 fail:
12464 {
12465 if (temp1)
12466 delete arg1;
12467 }
12468 return NULL;
12469 }
12470
12471
12472 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12473 PyObject *resultobj = NULL;
12474 wxString *arg1 = 0 ;
12475 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12476 int result;
12477 bool temp1 = false ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 char *kwnames[] = {
12481 (char *) "filename",(char *) "type", NULL
12482 };
12483
12484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12485 {
12486 arg1 = wxString_in_helper(obj0);
12487 if (arg1 == NULL) SWIG_fail;
12488 temp1 = true;
12489 }
12490 if (obj1) {
12491 {
12492 arg2 = static_cast<long >(SWIG_As_long(obj1));
12493 if (SWIG_arg_fail(2)) SWIG_fail;
12494 }
12495 }
12496 {
12497 PyThreadState* __tstate = wxPyBeginAllowThreads();
12498 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12499
12500 wxPyEndAllowThreads(__tstate);
12501 if (PyErr_Occurred()) SWIG_fail;
12502 }
12503 {
12504 resultobj = SWIG_From_int(static_cast<int >(result));
12505 }
12506 {
12507 if (temp1)
12508 delete arg1;
12509 }
12510 return resultobj;
12511 fail:
12512 {
12513 if (temp1)
12514 delete arg1;
12515 }
12516 return NULL;
12517 }
12518
12519
12520 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj = NULL;
12522 wxImage *arg1 = (wxImage *) 0 ;
12523 wxString *arg2 = 0 ;
12524 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12525 int arg4 = (int) -1 ;
12526 bool result;
12527 bool temp2 = false ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 PyObject * obj2 = 0 ;
12531 PyObject * obj3 = 0 ;
12532 char *kwnames[] = {
12533 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12534 };
12535
12536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12538 if (SWIG_arg_fail(1)) SWIG_fail;
12539 {
12540 arg2 = wxString_in_helper(obj1);
12541 if (arg2 == NULL) SWIG_fail;
12542 temp2 = true;
12543 }
12544 if (obj2) {
12545 {
12546 arg3 = static_cast<long >(SWIG_As_long(obj2));
12547 if (SWIG_arg_fail(3)) SWIG_fail;
12548 }
12549 }
12550 if (obj3) {
12551 {
12552 arg4 = static_cast<int >(SWIG_As_int(obj3));
12553 if (SWIG_arg_fail(4)) SWIG_fail;
12554 }
12555 }
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12559
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 {
12564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12565 }
12566 {
12567 if (temp2)
12568 delete arg2;
12569 }
12570 return resultobj;
12571 fail:
12572 {
12573 if (temp2)
12574 delete arg2;
12575 }
12576 return NULL;
12577 }
12578
12579
12580 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj = NULL;
12582 wxImage *arg1 = (wxImage *) 0 ;
12583 wxString *arg2 = 0 ;
12584 wxString *arg3 = 0 ;
12585 int arg4 = (int) -1 ;
12586 bool result;
12587 bool temp2 = false ;
12588 bool temp3 = false ;
12589 PyObject * obj0 = 0 ;
12590 PyObject * obj1 = 0 ;
12591 PyObject * obj2 = 0 ;
12592 PyObject * obj3 = 0 ;
12593 char *kwnames[] = {
12594 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12595 };
12596
12597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12599 if (SWIG_arg_fail(1)) SWIG_fail;
12600 {
12601 arg2 = wxString_in_helper(obj1);
12602 if (arg2 == NULL) SWIG_fail;
12603 temp2 = true;
12604 }
12605 {
12606 arg3 = wxString_in_helper(obj2);
12607 if (arg3 == NULL) SWIG_fail;
12608 temp3 = true;
12609 }
12610 if (obj3) {
12611 {
12612 arg4 = static_cast<int >(SWIG_As_int(obj3));
12613 if (SWIG_arg_fail(4)) SWIG_fail;
12614 }
12615 }
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12619
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 {
12624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12625 }
12626 {
12627 if (temp2)
12628 delete arg2;
12629 }
12630 {
12631 if (temp3)
12632 delete arg3;
12633 }
12634 return resultobj;
12635 fail:
12636 {
12637 if (temp2)
12638 delete arg2;
12639 }
12640 {
12641 if (temp3)
12642 delete arg3;
12643 }
12644 return NULL;
12645 }
12646
12647
12648 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12649 PyObject *resultobj = NULL;
12650 wxImage *arg1 = (wxImage *) 0 ;
12651 wxString *arg2 = 0 ;
12652 int arg3 ;
12653 bool result;
12654 bool temp2 = false ;
12655 PyObject * obj0 = 0 ;
12656 PyObject * obj1 = 0 ;
12657 PyObject * obj2 = 0 ;
12658 char *kwnames[] = {
12659 (char *) "self",(char *) "name",(char *) "type", NULL
12660 };
12661
12662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12664 if (SWIG_arg_fail(1)) SWIG_fail;
12665 {
12666 arg2 = wxString_in_helper(obj1);
12667 if (arg2 == NULL) SWIG_fail;
12668 temp2 = true;
12669 }
12670 {
12671 arg3 = static_cast<int >(SWIG_As_int(obj2));
12672 if (SWIG_arg_fail(3)) SWIG_fail;
12673 }
12674 {
12675 PyThreadState* __tstate = wxPyBeginAllowThreads();
12676 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12677
12678 wxPyEndAllowThreads(__tstate);
12679 if (PyErr_Occurred()) SWIG_fail;
12680 }
12681 {
12682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12683 }
12684 {
12685 if (temp2)
12686 delete arg2;
12687 }
12688 return resultobj;
12689 fail:
12690 {
12691 if (temp2)
12692 delete arg2;
12693 }
12694 return NULL;
12695 }
12696
12697
12698 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12699 PyObject *resultobj = NULL;
12700 wxImage *arg1 = (wxImage *) 0 ;
12701 wxString *arg2 = 0 ;
12702 wxString *arg3 = 0 ;
12703 bool result;
12704 bool temp2 = false ;
12705 bool temp3 = false ;
12706 PyObject * obj0 = 0 ;
12707 PyObject * obj1 = 0 ;
12708 PyObject * obj2 = 0 ;
12709 char *kwnames[] = {
12710 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12711 };
12712
12713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12715 if (SWIG_arg_fail(1)) SWIG_fail;
12716 {
12717 arg2 = wxString_in_helper(obj1);
12718 if (arg2 == NULL) SWIG_fail;
12719 temp2 = true;
12720 }
12721 {
12722 arg3 = wxString_in_helper(obj2);
12723 if (arg3 == NULL) SWIG_fail;
12724 temp3 = true;
12725 }
12726 {
12727 PyThreadState* __tstate = wxPyBeginAllowThreads();
12728 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12729
12730 wxPyEndAllowThreads(__tstate);
12731 if (PyErr_Occurred()) SWIG_fail;
12732 }
12733 {
12734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12735 }
12736 {
12737 if (temp2)
12738 delete arg2;
12739 }
12740 {
12741 if (temp3)
12742 delete arg3;
12743 }
12744 return resultobj;
12745 fail:
12746 {
12747 if (temp2)
12748 delete arg2;
12749 }
12750 {
12751 if (temp3)
12752 delete arg3;
12753 }
12754 return NULL;
12755 }
12756
12757
12758 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12759 PyObject *resultobj = NULL;
12760 wxInputStream *arg1 = 0 ;
12761 bool result;
12762 wxPyInputStream *temp1 ;
12763 bool created1 ;
12764 PyObject * obj0 = 0 ;
12765 char *kwnames[] = {
12766 (char *) "stream", NULL
12767 };
12768
12769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12770 {
12771 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12772 arg1 = temp1->m_wxis;
12773 created1 = false;
12774 } else {
12775 PyErr_Clear(); // clear the failure of the wxPyConvert above
12776 arg1 = wxPyCBInputStream_create(obj0, false);
12777 if (arg1 == NULL) {
12778 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12779 SWIG_fail;
12780 }
12781 created1 = true;
12782 }
12783 }
12784 {
12785 PyThreadState* __tstate = wxPyBeginAllowThreads();
12786 result = (bool)wxImage::CanRead(*arg1);
12787
12788 wxPyEndAllowThreads(__tstate);
12789 if (PyErr_Occurred()) SWIG_fail;
12790 }
12791 {
12792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12793 }
12794 {
12795 if (created1) delete arg1;
12796 }
12797 return resultobj;
12798 fail:
12799 {
12800 if (created1) delete arg1;
12801 }
12802 return NULL;
12803 }
12804
12805
12806 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12807 PyObject *resultobj = NULL;
12808 wxImage *arg1 = (wxImage *) 0 ;
12809 wxInputStream *arg2 = 0 ;
12810 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12811 int arg4 = (int) -1 ;
12812 bool result;
12813 wxPyInputStream *temp2 ;
12814 bool created2 ;
12815 PyObject * obj0 = 0 ;
12816 PyObject * obj1 = 0 ;
12817 PyObject * obj2 = 0 ;
12818 PyObject * obj3 = 0 ;
12819 char *kwnames[] = {
12820 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12821 };
12822
12823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12825 if (SWIG_arg_fail(1)) SWIG_fail;
12826 {
12827 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12828 arg2 = temp2->m_wxis;
12829 created2 = false;
12830 } else {
12831 PyErr_Clear(); // clear the failure of the wxPyConvert above
12832 arg2 = wxPyCBInputStream_create(obj1, false);
12833 if (arg2 == NULL) {
12834 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12835 SWIG_fail;
12836 }
12837 created2 = true;
12838 }
12839 }
12840 if (obj2) {
12841 {
12842 arg3 = static_cast<long >(SWIG_As_long(obj2));
12843 if (SWIG_arg_fail(3)) SWIG_fail;
12844 }
12845 }
12846 if (obj3) {
12847 {
12848 arg4 = static_cast<int >(SWIG_As_int(obj3));
12849 if (SWIG_arg_fail(4)) SWIG_fail;
12850 }
12851 }
12852 {
12853 PyThreadState* __tstate = wxPyBeginAllowThreads();
12854 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12855
12856 wxPyEndAllowThreads(__tstate);
12857 if (PyErr_Occurred()) SWIG_fail;
12858 }
12859 {
12860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12861 }
12862 {
12863 if (created2) delete arg2;
12864 }
12865 return resultobj;
12866 fail:
12867 {
12868 if (created2) delete arg2;
12869 }
12870 return NULL;
12871 }
12872
12873
12874 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12875 PyObject *resultobj = NULL;
12876 wxImage *arg1 = (wxImage *) 0 ;
12877 wxInputStream *arg2 = 0 ;
12878 wxString *arg3 = 0 ;
12879 int arg4 = (int) -1 ;
12880 bool result;
12881 wxPyInputStream *temp2 ;
12882 bool created2 ;
12883 bool temp3 = false ;
12884 PyObject * obj0 = 0 ;
12885 PyObject * obj1 = 0 ;
12886 PyObject * obj2 = 0 ;
12887 PyObject * obj3 = 0 ;
12888 char *kwnames[] = {
12889 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12890 };
12891
12892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12894 if (SWIG_arg_fail(1)) SWIG_fail;
12895 {
12896 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12897 arg2 = temp2->m_wxis;
12898 created2 = false;
12899 } else {
12900 PyErr_Clear(); // clear the failure of the wxPyConvert above
12901 arg2 = wxPyCBInputStream_create(obj1, false);
12902 if (arg2 == NULL) {
12903 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12904 SWIG_fail;
12905 }
12906 created2 = true;
12907 }
12908 }
12909 {
12910 arg3 = wxString_in_helper(obj2);
12911 if (arg3 == NULL) SWIG_fail;
12912 temp3 = true;
12913 }
12914 if (obj3) {
12915 {
12916 arg4 = static_cast<int >(SWIG_As_int(obj3));
12917 if (SWIG_arg_fail(4)) SWIG_fail;
12918 }
12919 }
12920 {
12921 PyThreadState* __tstate = wxPyBeginAllowThreads();
12922 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12923
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 {
12928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12929 }
12930 {
12931 if (created2) delete arg2;
12932 }
12933 {
12934 if (temp3)
12935 delete arg3;
12936 }
12937 return resultobj;
12938 fail:
12939 {
12940 if (created2) delete arg2;
12941 }
12942 {
12943 if (temp3)
12944 delete arg3;
12945 }
12946 return NULL;
12947 }
12948
12949
12950 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12951 PyObject *resultobj = NULL;
12952 wxImage *arg1 = (wxImage *) 0 ;
12953 bool result;
12954 PyObject * obj0 = 0 ;
12955 char *kwnames[] = {
12956 (char *) "self", NULL
12957 };
12958
12959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12961 if (SWIG_arg_fail(1)) SWIG_fail;
12962 {
12963 PyThreadState* __tstate = wxPyBeginAllowThreads();
12964 result = (bool)(arg1)->Ok();
12965
12966 wxPyEndAllowThreads(__tstate);
12967 if (PyErr_Occurred()) SWIG_fail;
12968 }
12969 {
12970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12971 }
12972 return resultobj;
12973 fail:
12974 return NULL;
12975 }
12976
12977
12978 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12979 PyObject *resultobj = NULL;
12980 wxImage *arg1 = (wxImage *) 0 ;
12981 int result;
12982 PyObject * obj0 = 0 ;
12983 char *kwnames[] = {
12984 (char *) "self", NULL
12985 };
12986
12987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12989 if (SWIG_arg_fail(1)) SWIG_fail;
12990 {
12991 PyThreadState* __tstate = wxPyBeginAllowThreads();
12992 result = (int)(arg1)->GetWidth();
12993
12994 wxPyEndAllowThreads(__tstate);
12995 if (PyErr_Occurred()) SWIG_fail;
12996 }
12997 {
12998 resultobj = SWIG_From_int(static_cast<int >(result));
12999 }
13000 return resultobj;
13001 fail:
13002 return NULL;
13003 }
13004
13005
13006 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
13007 PyObject *resultobj = NULL;
13008 wxImage *arg1 = (wxImage *) 0 ;
13009 int result;
13010 PyObject * obj0 = 0 ;
13011 char *kwnames[] = {
13012 (char *) "self", NULL
13013 };
13014
13015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
13016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13017 if (SWIG_arg_fail(1)) SWIG_fail;
13018 {
13019 PyThreadState* __tstate = wxPyBeginAllowThreads();
13020 result = (int)(arg1)->GetHeight();
13021
13022 wxPyEndAllowThreads(__tstate);
13023 if (PyErr_Occurred()) SWIG_fail;
13024 }
13025 {
13026 resultobj = SWIG_From_int(static_cast<int >(result));
13027 }
13028 return resultobj;
13029 fail:
13030 return NULL;
13031 }
13032
13033
13034 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
13035 PyObject *resultobj = NULL;
13036 wxImage *arg1 = (wxImage *) 0 ;
13037 wxSize result;
13038 PyObject * obj0 = 0 ;
13039 char *kwnames[] = {
13040 (char *) "self", NULL
13041 };
13042
13043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
13044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13045 if (SWIG_arg_fail(1)) SWIG_fail;
13046 {
13047 PyThreadState* __tstate = wxPyBeginAllowThreads();
13048 result = wxImage_GetSize(arg1);
13049
13050 wxPyEndAllowThreads(__tstate);
13051 if (PyErr_Occurred()) SWIG_fail;
13052 }
13053 {
13054 wxSize * resultptr;
13055 resultptr = new wxSize(static_cast<wxSize & >(result));
13056 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
13057 }
13058 return resultobj;
13059 fail:
13060 return NULL;
13061 }
13062
13063
13064 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13065 PyObject *resultobj = NULL;
13066 wxImage *arg1 = (wxImage *) 0 ;
13067 wxRect *arg2 = 0 ;
13068 SwigValueWrapper<wxImage > result;
13069 wxRect temp2 ;
13070 PyObject * obj0 = 0 ;
13071 PyObject * obj1 = 0 ;
13072 char *kwnames[] = {
13073 (char *) "self",(char *) "rect", NULL
13074 };
13075
13076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13078 if (SWIG_arg_fail(1)) SWIG_fail;
13079 {
13080 arg2 = &temp2;
13081 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13082 }
13083 {
13084 PyThreadState* __tstate = wxPyBeginAllowThreads();
13085 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13086
13087 wxPyEndAllowThreads(__tstate);
13088 if (PyErr_Occurred()) SWIG_fail;
13089 }
13090 {
13091 wxImage * resultptr;
13092 resultptr = new wxImage(static_cast<wxImage & >(result));
13093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13094 }
13095 return resultobj;
13096 fail:
13097 return NULL;
13098 }
13099
13100
13101 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13102 PyObject *resultobj = NULL;
13103 wxImage *arg1 = (wxImage *) 0 ;
13104 wxSize *arg2 = 0 ;
13105 wxPoint *arg3 = 0 ;
13106 int arg4 = (int) -1 ;
13107 int arg5 = (int) -1 ;
13108 int arg6 = (int) -1 ;
13109 SwigValueWrapper<wxImage > result;
13110 wxSize temp2 ;
13111 wxPoint temp3 ;
13112 PyObject * obj0 = 0 ;
13113 PyObject * obj1 = 0 ;
13114 PyObject * obj2 = 0 ;
13115 PyObject * obj3 = 0 ;
13116 PyObject * obj4 = 0 ;
13117 PyObject * obj5 = 0 ;
13118 char *kwnames[] = {
13119 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13120 };
13121
13122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13124 if (SWIG_arg_fail(1)) SWIG_fail;
13125 {
13126 arg2 = &temp2;
13127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13128 }
13129 {
13130 arg3 = &temp3;
13131 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13132 }
13133 if (obj3) {
13134 {
13135 arg4 = static_cast<int >(SWIG_As_int(obj3));
13136 if (SWIG_arg_fail(4)) SWIG_fail;
13137 }
13138 }
13139 if (obj4) {
13140 {
13141 arg5 = static_cast<int >(SWIG_As_int(obj4));
13142 if (SWIG_arg_fail(5)) SWIG_fail;
13143 }
13144 }
13145 if (obj5) {
13146 {
13147 arg6 = static_cast<int >(SWIG_As_int(obj5));
13148 if (SWIG_arg_fail(6)) SWIG_fail;
13149 }
13150 }
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13154
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 {
13159 wxImage * resultptr;
13160 resultptr = new wxImage(static_cast<wxImage & >(result));
13161 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13162 }
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj = NULL;
13171 wxImage *arg1 = (wxImage *) 0 ;
13172 SwigValueWrapper<wxImage > result;
13173 PyObject * obj0 = 0 ;
13174 char *kwnames[] = {
13175 (char *) "self", NULL
13176 };
13177
13178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13180 if (SWIG_arg_fail(1)) SWIG_fail;
13181 {
13182 PyThreadState* __tstate = wxPyBeginAllowThreads();
13183 result = (arg1)->Copy();
13184
13185 wxPyEndAllowThreads(__tstate);
13186 if (PyErr_Occurred()) SWIG_fail;
13187 }
13188 {
13189 wxImage * resultptr;
13190 resultptr = new wxImage(static_cast<wxImage & >(result));
13191 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13192 }
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13200 PyObject *resultobj = NULL;
13201 wxImage *arg1 = (wxImage *) 0 ;
13202 wxImage *arg2 = 0 ;
13203 int arg3 ;
13204 int arg4 ;
13205 PyObject * obj0 = 0 ;
13206 PyObject * obj1 = 0 ;
13207 PyObject * obj2 = 0 ;
13208 PyObject * obj3 = 0 ;
13209 char *kwnames[] = {
13210 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13211 };
13212
13213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13215 if (SWIG_arg_fail(1)) SWIG_fail;
13216 {
13217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13218 if (SWIG_arg_fail(2)) SWIG_fail;
13219 if (arg2 == NULL) {
13220 SWIG_null_ref("wxImage");
13221 }
13222 if (SWIG_arg_fail(2)) SWIG_fail;
13223 }
13224 {
13225 arg3 = static_cast<int >(SWIG_As_int(obj2));
13226 if (SWIG_arg_fail(3)) SWIG_fail;
13227 }
13228 {
13229 arg4 = static_cast<int >(SWIG_As_int(obj3));
13230 if (SWIG_arg_fail(4)) SWIG_fail;
13231 }
13232 {
13233 PyThreadState* __tstate = wxPyBeginAllowThreads();
13234 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13235
13236 wxPyEndAllowThreads(__tstate);
13237 if (PyErr_Occurred()) SWIG_fail;
13238 }
13239 Py_INCREF(Py_None); resultobj = Py_None;
13240 return resultobj;
13241 fail:
13242 return NULL;
13243 }
13244
13245
13246 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13247 PyObject *resultobj = NULL;
13248 wxImage *arg1 = (wxImage *) 0 ;
13249 PyObject *result;
13250 PyObject * obj0 = 0 ;
13251 char *kwnames[] = {
13252 (char *) "self", NULL
13253 };
13254
13255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13257 if (SWIG_arg_fail(1)) SWIG_fail;
13258 {
13259 PyThreadState* __tstate = wxPyBeginAllowThreads();
13260 result = (PyObject *)wxImage_GetData(arg1);
13261
13262 wxPyEndAllowThreads(__tstate);
13263 if (PyErr_Occurred()) SWIG_fail;
13264 }
13265 resultobj = result;
13266 return resultobj;
13267 fail:
13268 return NULL;
13269 }
13270
13271
13272 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13273 PyObject *resultobj = NULL;
13274 wxImage *arg1 = (wxImage *) 0 ;
13275 buffer arg2 ;
13276 int arg3 ;
13277 PyObject * obj0 = 0 ;
13278 PyObject * obj1 = 0 ;
13279 char *kwnames[] = {
13280 (char *) "self",(char *) "data", NULL
13281 };
13282
13283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13285 if (SWIG_arg_fail(1)) SWIG_fail;
13286 {
13287 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13288 }
13289 {
13290 PyThreadState* __tstate = wxPyBeginAllowThreads();
13291 wxImage_SetData(arg1,arg2,arg3);
13292
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 Py_INCREF(Py_None); resultobj = Py_None;
13297 return resultobj;
13298 fail:
13299 return NULL;
13300 }
13301
13302
13303 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13304 PyObject *resultobj = NULL;
13305 wxImage *arg1 = (wxImage *) 0 ;
13306 PyObject *result;
13307 PyObject * obj0 = 0 ;
13308 char *kwnames[] = {
13309 (char *) "self", NULL
13310 };
13311
13312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13314 if (SWIG_arg_fail(1)) SWIG_fail;
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13318
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 resultobj = result;
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj = NULL;
13331 wxImage *arg1 = (wxImage *) 0 ;
13332 buffer arg2 ;
13333 int arg3 ;
13334 PyObject * obj0 = 0 ;
13335 PyObject * obj1 = 0 ;
13336 char *kwnames[] = {
13337 (char *) "self",(char *) "data", NULL
13338 };
13339
13340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13342 if (SWIG_arg_fail(1)) SWIG_fail;
13343 {
13344 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13345 }
13346 {
13347 PyThreadState* __tstate = wxPyBeginAllowThreads();
13348 wxImage_SetDataBuffer(arg1,arg2,arg3);
13349
13350 wxPyEndAllowThreads(__tstate);
13351 if (PyErr_Occurred()) SWIG_fail;
13352 }
13353 Py_INCREF(Py_None); resultobj = Py_None;
13354 return resultobj;
13355 fail:
13356 return NULL;
13357 }
13358
13359
13360 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13361 PyObject *resultobj = NULL;
13362 wxImage *arg1 = (wxImage *) 0 ;
13363 PyObject *result;
13364 PyObject * obj0 = 0 ;
13365 char *kwnames[] = {
13366 (char *) "self", NULL
13367 };
13368
13369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13371 if (SWIG_arg_fail(1)) SWIG_fail;
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 result = (PyObject *)wxImage_GetAlphaData(arg1);
13375
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 resultobj = result;
13380 return resultobj;
13381 fail:
13382 return NULL;
13383 }
13384
13385
13386 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13387 PyObject *resultobj = NULL;
13388 wxImage *arg1 = (wxImage *) 0 ;
13389 buffer arg2 ;
13390 int arg3 ;
13391 PyObject * obj0 = 0 ;
13392 PyObject * obj1 = 0 ;
13393 char *kwnames[] = {
13394 (char *) "self",(char *) "alpha", NULL
13395 };
13396
13397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13399 if (SWIG_arg_fail(1)) SWIG_fail;
13400 {
13401 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13402 }
13403 {
13404 PyThreadState* __tstate = wxPyBeginAllowThreads();
13405 wxImage_SetAlphaData(arg1,arg2,arg3);
13406
13407 wxPyEndAllowThreads(__tstate);
13408 if (PyErr_Occurred()) SWIG_fail;
13409 }
13410 Py_INCREF(Py_None); resultobj = Py_None;
13411 return resultobj;
13412 fail:
13413 return NULL;
13414 }
13415
13416
13417 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13418 PyObject *resultobj = NULL;
13419 wxImage *arg1 = (wxImage *) 0 ;
13420 PyObject *result;
13421 PyObject * obj0 = 0 ;
13422 char *kwnames[] = {
13423 (char *) "self", NULL
13424 };
13425
13426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13428 if (SWIG_arg_fail(1)) SWIG_fail;
13429 {
13430 PyThreadState* __tstate = wxPyBeginAllowThreads();
13431 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13432
13433 wxPyEndAllowThreads(__tstate);
13434 if (PyErr_Occurred()) SWIG_fail;
13435 }
13436 resultobj = result;
13437 return resultobj;
13438 fail:
13439 return NULL;
13440 }
13441
13442
13443 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13444 PyObject *resultobj = NULL;
13445 wxImage *arg1 = (wxImage *) 0 ;
13446 buffer arg2 ;
13447 int arg3 ;
13448 PyObject * obj0 = 0 ;
13449 PyObject * obj1 = 0 ;
13450 char *kwnames[] = {
13451 (char *) "self",(char *) "alpha", NULL
13452 };
13453
13454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13456 if (SWIG_arg_fail(1)) SWIG_fail;
13457 {
13458 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13459 }
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13463
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 Py_INCREF(Py_None); resultobj = Py_None;
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13475 PyObject *resultobj = NULL;
13476 wxImage *arg1 = (wxImage *) 0 ;
13477 byte arg2 ;
13478 byte arg3 ;
13479 byte arg4 ;
13480 PyObject * obj0 = 0 ;
13481 PyObject * obj1 = 0 ;
13482 PyObject * obj2 = 0 ;
13483 PyObject * obj3 = 0 ;
13484 char *kwnames[] = {
13485 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13486 };
13487
13488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13490 if (SWIG_arg_fail(1)) SWIG_fail;
13491 {
13492 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13493 if (SWIG_arg_fail(2)) SWIG_fail;
13494 }
13495 {
13496 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13497 if (SWIG_arg_fail(3)) SWIG_fail;
13498 }
13499 {
13500 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13501 if (SWIG_arg_fail(4)) SWIG_fail;
13502 }
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 (arg1)->SetMaskColour(arg2,arg3,arg4);
13506
13507 wxPyEndAllowThreads(__tstate);
13508 if (PyErr_Occurred()) SWIG_fail;
13509 }
13510 Py_INCREF(Py_None); resultobj = Py_None;
13511 return resultobj;
13512 fail:
13513 return NULL;
13514 }
13515
13516
13517 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13518 PyObject *resultobj = NULL;
13519 wxImage *arg1 = (wxImage *) 0 ;
13520 byte *arg2 = (byte *) 0 ;
13521 byte *arg3 = (byte *) 0 ;
13522 byte *arg4 = (byte *) 0 ;
13523 byte temp2 ;
13524 int res2 = 0 ;
13525 byte temp3 ;
13526 int res3 = 0 ;
13527 byte temp4 ;
13528 int res4 = 0 ;
13529 PyObject * obj0 = 0 ;
13530 char *kwnames[] = {
13531 (char *) "self", NULL
13532 };
13533
13534 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13535 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13536 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13539 if (SWIG_arg_fail(1)) SWIG_fail;
13540 {
13541 PyThreadState* __tstate = wxPyBeginAllowThreads();
13542 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13543
13544 wxPyEndAllowThreads(__tstate);
13545 if (PyErr_Occurred()) SWIG_fail;
13546 }
13547 Py_INCREF(Py_None); resultobj = Py_None;
13548 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13549 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13550 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13551 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13552 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13553 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13554 return resultobj;
13555 fail:
13556 return NULL;
13557 }
13558
13559
13560 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13561 PyObject *resultobj = NULL;
13562 wxImage *arg1 = (wxImage *) 0 ;
13563 byte result;
13564 PyObject * obj0 = 0 ;
13565 char *kwnames[] = {
13566 (char *) "self", NULL
13567 };
13568
13569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13571 if (SWIG_arg_fail(1)) SWIG_fail;
13572 {
13573 PyThreadState* __tstate = wxPyBeginAllowThreads();
13574 result = (byte)(arg1)->GetMaskRed();
13575
13576 wxPyEndAllowThreads(__tstate);
13577 if (PyErr_Occurred()) SWIG_fail;
13578 }
13579 {
13580 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13581 }
13582 return resultobj;
13583 fail:
13584 return NULL;
13585 }
13586
13587
13588 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13589 PyObject *resultobj = NULL;
13590 wxImage *arg1 = (wxImage *) 0 ;
13591 byte result;
13592 PyObject * obj0 = 0 ;
13593 char *kwnames[] = {
13594 (char *) "self", NULL
13595 };
13596
13597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13599 if (SWIG_arg_fail(1)) SWIG_fail;
13600 {
13601 PyThreadState* __tstate = wxPyBeginAllowThreads();
13602 result = (byte)(arg1)->GetMaskGreen();
13603
13604 wxPyEndAllowThreads(__tstate);
13605 if (PyErr_Occurred()) SWIG_fail;
13606 }
13607 {
13608 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13609 }
13610 return resultobj;
13611 fail:
13612 return NULL;
13613 }
13614
13615
13616 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13617 PyObject *resultobj = NULL;
13618 wxImage *arg1 = (wxImage *) 0 ;
13619 byte result;
13620 PyObject * obj0 = 0 ;
13621 char *kwnames[] = {
13622 (char *) "self", NULL
13623 };
13624
13625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13627 if (SWIG_arg_fail(1)) SWIG_fail;
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 result = (byte)(arg1)->GetMaskBlue();
13631
13632 wxPyEndAllowThreads(__tstate);
13633 if (PyErr_Occurred()) SWIG_fail;
13634 }
13635 {
13636 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13637 }
13638 return resultobj;
13639 fail:
13640 return NULL;
13641 }
13642
13643
13644 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13645 PyObject *resultobj = NULL;
13646 wxImage *arg1 = (wxImage *) 0 ;
13647 bool arg2 = (bool) true ;
13648 PyObject * obj0 = 0 ;
13649 PyObject * obj1 = 0 ;
13650 char *kwnames[] = {
13651 (char *) "self",(char *) "mask", NULL
13652 };
13653
13654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13656 if (SWIG_arg_fail(1)) SWIG_fail;
13657 if (obj1) {
13658 {
13659 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13660 if (SWIG_arg_fail(2)) SWIG_fail;
13661 }
13662 }
13663 {
13664 PyThreadState* __tstate = wxPyBeginAllowThreads();
13665 (arg1)->SetMask(arg2);
13666
13667 wxPyEndAllowThreads(__tstate);
13668 if (PyErr_Occurred()) SWIG_fail;
13669 }
13670 Py_INCREF(Py_None); resultobj = Py_None;
13671 return resultobj;
13672 fail:
13673 return NULL;
13674 }
13675
13676
13677 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13678 PyObject *resultobj = NULL;
13679 wxImage *arg1 = (wxImage *) 0 ;
13680 bool result;
13681 PyObject * obj0 = 0 ;
13682 char *kwnames[] = {
13683 (char *) "self", NULL
13684 };
13685
13686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13688 if (SWIG_arg_fail(1)) SWIG_fail;
13689 {
13690 PyThreadState* __tstate = wxPyBeginAllowThreads();
13691 result = (bool)(arg1)->HasMask();
13692
13693 wxPyEndAllowThreads(__tstate);
13694 if (PyErr_Occurred()) SWIG_fail;
13695 }
13696 {
13697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13698 }
13699 return resultobj;
13700 fail:
13701 return NULL;
13702 }
13703
13704
13705 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13706 PyObject *resultobj = NULL;
13707 wxImage *arg1 = (wxImage *) 0 ;
13708 double arg2 ;
13709 wxPoint *arg3 = 0 ;
13710 bool arg4 = (bool) true ;
13711 wxPoint *arg5 = (wxPoint *) NULL ;
13712 SwigValueWrapper<wxImage > result;
13713 wxPoint temp3 ;
13714 PyObject * obj0 = 0 ;
13715 PyObject * obj1 = 0 ;
13716 PyObject * obj2 = 0 ;
13717 PyObject * obj3 = 0 ;
13718 PyObject * obj4 = 0 ;
13719 char *kwnames[] = {
13720 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13721 };
13722
13723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13725 if (SWIG_arg_fail(1)) SWIG_fail;
13726 {
13727 arg2 = static_cast<double >(SWIG_As_double(obj1));
13728 if (SWIG_arg_fail(2)) SWIG_fail;
13729 }
13730 {
13731 arg3 = &temp3;
13732 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13733 }
13734 if (obj3) {
13735 {
13736 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13737 if (SWIG_arg_fail(4)) SWIG_fail;
13738 }
13739 }
13740 if (obj4) {
13741 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13742 if (SWIG_arg_fail(5)) SWIG_fail;
13743 }
13744 {
13745 PyThreadState* __tstate = wxPyBeginAllowThreads();
13746 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13747
13748 wxPyEndAllowThreads(__tstate);
13749 if (PyErr_Occurred()) SWIG_fail;
13750 }
13751 {
13752 wxImage * resultptr;
13753 resultptr = new wxImage(static_cast<wxImage & >(result));
13754 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13755 }
13756 return resultobj;
13757 fail:
13758 return NULL;
13759 }
13760
13761
13762 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13763 PyObject *resultobj = NULL;
13764 wxImage *arg1 = (wxImage *) 0 ;
13765 bool arg2 = (bool) true ;
13766 SwigValueWrapper<wxImage > result;
13767 PyObject * obj0 = 0 ;
13768 PyObject * obj1 = 0 ;
13769 char *kwnames[] = {
13770 (char *) "self",(char *) "clockwise", NULL
13771 };
13772
13773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13775 if (SWIG_arg_fail(1)) SWIG_fail;
13776 if (obj1) {
13777 {
13778 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13779 if (SWIG_arg_fail(2)) SWIG_fail;
13780 }
13781 }
13782 {
13783 PyThreadState* __tstate = wxPyBeginAllowThreads();
13784 result = (arg1)->Rotate90(arg2);
13785
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 {
13790 wxImage * resultptr;
13791 resultptr = new wxImage(static_cast<wxImage & >(result));
13792 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13793 }
13794 return resultobj;
13795 fail:
13796 return NULL;
13797 }
13798
13799
13800 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13801 PyObject *resultobj = NULL;
13802 wxImage *arg1 = (wxImage *) 0 ;
13803 bool arg2 = (bool) true ;
13804 SwigValueWrapper<wxImage > result;
13805 PyObject * obj0 = 0 ;
13806 PyObject * obj1 = 0 ;
13807 char *kwnames[] = {
13808 (char *) "self",(char *) "horizontally", NULL
13809 };
13810
13811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13813 if (SWIG_arg_fail(1)) SWIG_fail;
13814 if (obj1) {
13815 {
13816 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13817 if (SWIG_arg_fail(2)) SWIG_fail;
13818 }
13819 }
13820 {
13821 PyThreadState* __tstate = wxPyBeginAllowThreads();
13822 result = (arg1)->Mirror(arg2);
13823
13824 wxPyEndAllowThreads(__tstate);
13825 if (PyErr_Occurred()) SWIG_fail;
13826 }
13827 {
13828 wxImage * resultptr;
13829 resultptr = new wxImage(static_cast<wxImage & >(result));
13830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13831 }
13832 return resultobj;
13833 fail:
13834 return NULL;
13835 }
13836
13837
13838 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13839 PyObject *resultobj = NULL;
13840 wxImage *arg1 = (wxImage *) 0 ;
13841 byte arg2 ;
13842 byte arg3 ;
13843 byte arg4 ;
13844 byte arg5 ;
13845 byte arg6 ;
13846 byte arg7 ;
13847 PyObject * obj0 = 0 ;
13848 PyObject * obj1 = 0 ;
13849 PyObject * obj2 = 0 ;
13850 PyObject * obj3 = 0 ;
13851 PyObject * obj4 = 0 ;
13852 PyObject * obj5 = 0 ;
13853 PyObject * obj6 = 0 ;
13854 char *kwnames[] = {
13855 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13856 };
13857
13858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13860 if (SWIG_arg_fail(1)) SWIG_fail;
13861 {
13862 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13863 if (SWIG_arg_fail(2)) SWIG_fail;
13864 }
13865 {
13866 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13867 if (SWIG_arg_fail(3)) SWIG_fail;
13868 }
13869 {
13870 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13871 if (SWIG_arg_fail(4)) SWIG_fail;
13872 }
13873 {
13874 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13875 if (SWIG_arg_fail(5)) SWIG_fail;
13876 }
13877 {
13878 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13879 if (SWIG_arg_fail(6)) SWIG_fail;
13880 }
13881 {
13882 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13883 if (SWIG_arg_fail(7)) SWIG_fail;
13884 }
13885 {
13886 PyThreadState* __tstate = wxPyBeginAllowThreads();
13887 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13888
13889 wxPyEndAllowThreads(__tstate);
13890 if (PyErr_Occurred()) SWIG_fail;
13891 }
13892 Py_INCREF(Py_None); resultobj = Py_None;
13893 return resultobj;
13894 fail:
13895 return NULL;
13896 }
13897
13898
13899 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13900 PyObject *resultobj = NULL;
13901 wxImage *arg1 = (wxImage *) 0 ;
13902 double arg2 = (double) 0.299 ;
13903 double arg3 = (double) 0.587 ;
13904 double arg4 = (double) 0.114 ;
13905 SwigValueWrapper<wxImage > result;
13906 PyObject * obj0 = 0 ;
13907 PyObject * obj1 = 0 ;
13908 PyObject * obj2 = 0 ;
13909 PyObject * obj3 = 0 ;
13910 char *kwnames[] = {
13911 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13912 };
13913
13914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13916 if (SWIG_arg_fail(1)) SWIG_fail;
13917 if (obj1) {
13918 {
13919 arg2 = static_cast<double >(SWIG_As_double(obj1));
13920 if (SWIG_arg_fail(2)) SWIG_fail;
13921 }
13922 }
13923 if (obj2) {
13924 {
13925 arg3 = static_cast<double >(SWIG_As_double(obj2));
13926 if (SWIG_arg_fail(3)) SWIG_fail;
13927 }
13928 }
13929 if (obj3) {
13930 {
13931 arg4 = static_cast<double >(SWIG_As_double(obj3));
13932 if (SWIG_arg_fail(4)) SWIG_fail;
13933 }
13934 }
13935 {
13936 PyThreadState* __tstate = wxPyBeginAllowThreads();
13937 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13938
13939 wxPyEndAllowThreads(__tstate);
13940 if (PyErr_Occurred()) SWIG_fail;
13941 }
13942 {
13943 wxImage * resultptr;
13944 resultptr = new wxImage(static_cast<wxImage & >(result));
13945 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13946 }
13947 return resultobj;
13948 fail:
13949 return NULL;
13950 }
13951
13952
13953 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13954 PyObject *resultobj = NULL;
13955 wxImage *arg1 = (wxImage *) 0 ;
13956 byte arg2 ;
13957 byte arg3 ;
13958 byte arg4 ;
13959 SwigValueWrapper<wxImage > result;
13960 PyObject * obj0 = 0 ;
13961 PyObject * obj1 = 0 ;
13962 PyObject * obj2 = 0 ;
13963 PyObject * obj3 = 0 ;
13964 char *kwnames[] = {
13965 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13966 };
13967
13968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13970 if (SWIG_arg_fail(1)) SWIG_fail;
13971 {
13972 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13973 if (SWIG_arg_fail(2)) SWIG_fail;
13974 }
13975 {
13976 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13977 if (SWIG_arg_fail(3)) SWIG_fail;
13978 }
13979 {
13980 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13981 if (SWIG_arg_fail(4)) SWIG_fail;
13982 }
13983 {
13984 PyThreadState* __tstate = wxPyBeginAllowThreads();
13985 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13986
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 {
13991 wxImage * resultptr;
13992 resultptr = new wxImage(static_cast<wxImage & >(result));
13993 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13994 }
13995 return resultobj;
13996 fail:
13997 return NULL;
13998 }
13999
14000
14001 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14002 PyObject *resultobj = NULL;
14003 wxImage *arg1 = (wxImage *) 0 ;
14004 wxString *arg2 = 0 ;
14005 wxString *arg3 = 0 ;
14006 bool temp2 = false ;
14007 bool temp3 = false ;
14008 PyObject * obj0 = 0 ;
14009 PyObject * obj1 = 0 ;
14010 PyObject * obj2 = 0 ;
14011 char *kwnames[] = {
14012 (char *) "self",(char *) "name",(char *) "value", NULL
14013 };
14014
14015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
14016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14017 if (SWIG_arg_fail(1)) SWIG_fail;
14018 {
14019 arg2 = wxString_in_helper(obj1);
14020 if (arg2 == NULL) SWIG_fail;
14021 temp2 = true;
14022 }
14023 {
14024 arg3 = wxString_in_helper(obj2);
14025 if (arg3 == NULL) SWIG_fail;
14026 temp3 = true;
14027 }
14028 {
14029 PyThreadState* __tstate = wxPyBeginAllowThreads();
14030 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
14031
14032 wxPyEndAllowThreads(__tstate);
14033 if (PyErr_Occurred()) SWIG_fail;
14034 }
14035 Py_INCREF(Py_None); resultobj = Py_None;
14036 {
14037 if (temp2)
14038 delete arg2;
14039 }
14040 {
14041 if (temp3)
14042 delete arg3;
14043 }
14044 return resultobj;
14045 fail:
14046 {
14047 if (temp2)
14048 delete arg2;
14049 }
14050 {
14051 if (temp3)
14052 delete arg3;
14053 }
14054 return NULL;
14055 }
14056
14057
14058 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14059 PyObject *resultobj = NULL;
14060 wxImage *arg1 = (wxImage *) 0 ;
14061 wxString *arg2 = 0 ;
14062 int arg3 ;
14063 bool temp2 = false ;
14064 PyObject * obj0 = 0 ;
14065 PyObject * obj1 = 0 ;
14066 PyObject * obj2 = 0 ;
14067 char *kwnames[] = {
14068 (char *) "self",(char *) "name",(char *) "value", NULL
14069 };
14070
14071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14073 if (SWIG_arg_fail(1)) SWIG_fail;
14074 {
14075 arg2 = wxString_in_helper(obj1);
14076 if (arg2 == NULL) SWIG_fail;
14077 temp2 = true;
14078 }
14079 {
14080 arg3 = static_cast<int >(SWIG_As_int(obj2));
14081 if (SWIG_arg_fail(3)) SWIG_fail;
14082 }
14083 {
14084 PyThreadState* __tstate = wxPyBeginAllowThreads();
14085 (arg1)->SetOption((wxString const &)*arg2,arg3);
14086
14087 wxPyEndAllowThreads(__tstate);
14088 if (PyErr_Occurred()) SWIG_fail;
14089 }
14090 Py_INCREF(Py_None); resultobj = Py_None;
14091 {
14092 if (temp2)
14093 delete arg2;
14094 }
14095 return resultobj;
14096 fail:
14097 {
14098 if (temp2)
14099 delete arg2;
14100 }
14101 return NULL;
14102 }
14103
14104
14105 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14106 PyObject *resultobj = NULL;
14107 wxImage *arg1 = (wxImage *) 0 ;
14108 wxString *arg2 = 0 ;
14109 wxString result;
14110 bool temp2 = false ;
14111 PyObject * obj0 = 0 ;
14112 PyObject * obj1 = 0 ;
14113 char *kwnames[] = {
14114 (char *) "self",(char *) "name", NULL
14115 };
14116
14117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14119 if (SWIG_arg_fail(1)) SWIG_fail;
14120 {
14121 arg2 = wxString_in_helper(obj1);
14122 if (arg2 == NULL) SWIG_fail;
14123 temp2 = true;
14124 }
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14128
14129 wxPyEndAllowThreads(__tstate);
14130 if (PyErr_Occurred()) SWIG_fail;
14131 }
14132 {
14133 #if wxUSE_UNICODE
14134 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14135 #else
14136 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14137 #endif
14138 }
14139 {
14140 if (temp2)
14141 delete arg2;
14142 }
14143 return resultobj;
14144 fail:
14145 {
14146 if (temp2)
14147 delete arg2;
14148 }
14149 return NULL;
14150 }
14151
14152
14153 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14154 PyObject *resultobj = NULL;
14155 wxImage *arg1 = (wxImage *) 0 ;
14156 wxString *arg2 = 0 ;
14157 int result;
14158 bool temp2 = false ;
14159 PyObject * obj0 = 0 ;
14160 PyObject * obj1 = 0 ;
14161 char *kwnames[] = {
14162 (char *) "self",(char *) "name", NULL
14163 };
14164
14165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
14166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14167 if (SWIG_arg_fail(1)) SWIG_fail;
14168 {
14169 arg2 = wxString_in_helper(obj1);
14170 if (arg2 == NULL) SWIG_fail;
14171 temp2 = true;
14172 }
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14176
14177 wxPyEndAllowThreads(__tstate);
14178 if (PyErr_Occurred()) SWIG_fail;
14179 }
14180 {
14181 resultobj = SWIG_From_int(static_cast<int >(result));
14182 }
14183 {
14184 if (temp2)
14185 delete arg2;
14186 }
14187 return resultobj;
14188 fail:
14189 {
14190 if (temp2)
14191 delete arg2;
14192 }
14193 return NULL;
14194 }
14195
14196
14197 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj = NULL;
14199 wxImage *arg1 = (wxImage *) 0 ;
14200 wxString *arg2 = 0 ;
14201 bool result;
14202 bool temp2 = false ;
14203 PyObject * obj0 = 0 ;
14204 PyObject * obj1 = 0 ;
14205 char *kwnames[] = {
14206 (char *) "self",(char *) "name", NULL
14207 };
14208
14209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14211 if (SWIG_arg_fail(1)) SWIG_fail;
14212 {
14213 arg2 = wxString_in_helper(obj1);
14214 if (arg2 == NULL) SWIG_fail;
14215 temp2 = true;
14216 }
14217 {
14218 PyThreadState* __tstate = wxPyBeginAllowThreads();
14219 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14220
14221 wxPyEndAllowThreads(__tstate);
14222 if (PyErr_Occurred()) SWIG_fail;
14223 }
14224 {
14225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14226 }
14227 {
14228 if (temp2)
14229 delete arg2;
14230 }
14231 return resultobj;
14232 fail:
14233 {
14234 if (temp2)
14235 delete arg2;
14236 }
14237 return NULL;
14238 }
14239
14240
14241 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14242 PyObject *resultobj = NULL;
14243 wxImage *arg1 = (wxImage *) 0 ;
14244 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14245 unsigned long result;
14246 PyObject * obj0 = 0 ;
14247 PyObject * obj1 = 0 ;
14248 char *kwnames[] = {
14249 (char *) "self",(char *) "stopafter", NULL
14250 };
14251
14252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14254 if (SWIG_arg_fail(1)) SWIG_fail;
14255 if (obj1) {
14256 {
14257 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14258 if (SWIG_arg_fail(2)) SWIG_fail;
14259 }
14260 }
14261 {
14262 PyThreadState* __tstate = wxPyBeginAllowThreads();
14263 result = (unsigned long)(arg1)->CountColours(arg2);
14264
14265 wxPyEndAllowThreads(__tstate);
14266 if (PyErr_Occurred()) SWIG_fail;
14267 }
14268 {
14269 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14270 }
14271 return resultobj;
14272 fail:
14273 return NULL;
14274 }
14275
14276
14277 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14278 PyObject *resultobj = NULL;
14279 wxImage *arg1 = (wxImage *) 0 ;
14280 wxImageHistogram *arg2 = 0 ;
14281 unsigned long result;
14282 PyObject * obj0 = 0 ;
14283 PyObject * obj1 = 0 ;
14284 char *kwnames[] = {
14285 (char *) "self",(char *) "h", NULL
14286 };
14287
14288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14290 if (SWIG_arg_fail(1)) SWIG_fail;
14291 {
14292 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14293 if (SWIG_arg_fail(2)) SWIG_fail;
14294 if (arg2 == NULL) {
14295 SWIG_null_ref("wxImageHistogram");
14296 }
14297 if (SWIG_arg_fail(2)) SWIG_fail;
14298 }
14299 {
14300 PyThreadState* __tstate = wxPyBeginAllowThreads();
14301 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14302
14303 wxPyEndAllowThreads(__tstate);
14304 if (PyErr_Occurred()) SWIG_fail;
14305 }
14306 {
14307 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14308 }
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14316 PyObject *resultobj = NULL;
14317 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14318 PyObject * obj0 = 0 ;
14319 char *kwnames[] = {
14320 (char *) "handler", NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14325 if (SWIG_arg_fail(1)) SWIG_fail;
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 wxImage::AddHandler(arg1);
14329
14330 wxPyEndAllowThreads(__tstate);
14331 if (PyErr_Occurred()) SWIG_fail;
14332 }
14333 Py_INCREF(Py_None); resultobj = Py_None;
14334 return resultobj;
14335 fail:
14336 return NULL;
14337 }
14338
14339
14340 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = NULL;
14342 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14343 PyObject * obj0 = 0 ;
14344 char *kwnames[] = {
14345 (char *) "handler", NULL
14346 };
14347
14348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14350 if (SWIG_arg_fail(1)) SWIG_fail;
14351 {
14352 PyThreadState* __tstate = wxPyBeginAllowThreads();
14353 wxImage::InsertHandler(arg1);
14354
14355 wxPyEndAllowThreads(__tstate);
14356 if (PyErr_Occurred()) SWIG_fail;
14357 }
14358 Py_INCREF(Py_None); resultobj = Py_None;
14359 return resultobj;
14360 fail:
14361 return NULL;
14362 }
14363
14364
14365 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14366 PyObject *resultobj = NULL;
14367 wxString *arg1 = 0 ;
14368 bool result;
14369 bool temp1 = false ;
14370 PyObject * obj0 = 0 ;
14371 char *kwnames[] = {
14372 (char *) "name", NULL
14373 };
14374
14375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14376 {
14377 arg1 = wxString_in_helper(obj0);
14378 if (arg1 == NULL) SWIG_fail;
14379 temp1 = true;
14380 }
14381 {
14382 PyThreadState* __tstate = wxPyBeginAllowThreads();
14383 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14384
14385 wxPyEndAllowThreads(__tstate);
14386 if (PyErr_Occurred()) SWIG_fail;
14387 }
14388 {
14389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14390 }
14391 {
14392 if (temp1)
14393 delete arg1;
14394 }
14395 return resultobj;
14396 fail:
14397 {
14398 if (temp1)
14399 delete arg1;
14400 }
14401 return NULL;
14402 }
14403
14404
14405 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14406 PyObject *resultobj = NULL;
14407 wxString result;
14408 char *kwnames[] = {
14409 NULL
14410 };
14411
14412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = wxImage::GetImageExtWildcard();
14416
14417 wxPyEndAllowThreads(__tstate);
14418 if (PyErr_Occurred()) SWIG_fail;
14419 }
14420 {
14421 #if wxUSE_UNICODE
14422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14423 #else
14424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14425 #endif
14426 }
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj = NULL;
14435 wxImage *arg1 = (wxImage *) 0 ;
14436 int arg2 = (int) -1 ;
14437 wxBitmap result;
14438 PyObject * obj0 = 0 ;
14439 PyObject * obj1 = 0 ;
14440 char *kwnames[] = {
14441 (char *) "self",(char *) "depth", NULL
14442 };
14443
14444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14446 if (SWIG_arg_fail(1)) SWIG_fail;
14447 if (obj1) {
14448 {
14449 arg2 = static_cast<int >(SWIG_As_int(obj1));
14450 if (SWIG_arg_fail(2)) SWIG_fail;
14451 }
14452 }
14453 {
14454 if (!wxPyCheckForApp()) SWIG_fail;
14455 PyThreadState* __tstate = wxPyBeginAllowThreads();
14456 result = wxImage_ConvertToBitmap(arg1,arg2);
14457
14458 wxPyEndAllowThreads(__tstate);
14459 if (PyErr_Occurred()) SWIG_fail;
14460 }
14461 {
14462 wxBitmap * resultptr;
14463 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14464 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14465 }
14466 return resultobj;
14467 fail:
14468 return NULL;
14469 }
14470
14471
14472 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14473 PyObject *resultobj = NULL;
14474 wxImage *arg1 = (wxImage *) 0 ;
14475 byte arg2 ;
14476 byte arg3 ;
14477 byte arg4 ;
14478 wxBitmap result;
14479 PyObject * obj0 = 0 ;
14480 PyObject * obj1 = 0 ;
14481 PyObject * obj2 = 0 ;
14482 PyObject * obj3 = 0 ;
14483 char *kwnames[] = {
14484 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14485 };
14486
14487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14489 if (SWIG_arg_fail(1)) SWIG_fail;
14490 {
14491 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14492 if (SWIG_arg_fail(2)) SWIG_fail;
14493 }
14494 {
14495 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14496 if (SWIG_arg_fail(3)) SWIG_fail;
14497 }
14498 {
14499 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14500 if (SWIG_arg_fail(4)) SWIG_fail;
14501 }
14502 {
14503 if (!wxPyCheckForApp()) SWIG_fail;
14504 PyThreadState* __tstate = wxPyBeginAllowThreads();
14505 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14506
14507 wxPyEndAllowThreads(__tstate);
14508 if (PyErr_Occurred()) SWIG_fail;
14509 }
14510 {
14511 wxBitmap * resultptr;
14512 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14514 }
14515 return resultobj;
14516 fail:
14517 return NULL;
14518 }
14519
14520
14521 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14522 PyObject *resultobj = NULL;
14523 wxImage *arg1 = (wxImage *) 0 ;
14524 double arg2 ;
14525 PyObject * obj0 = 0 ;
14526 PyObject * obj1 = 0 ;
14527 char *kwnames[] = {
14528 (char *) "self",(char *) "angle", NULL
14529 };
14530
14531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14533 if (SWIG_arg_fail(1)) SWIG_fail;
14534 {
14535 arg2 = static_cast<double >(SWIG_As_double(obj1));
14536 if (SWIG_arg_fail(2)) SWIG_fail;
14537 }
14538 {
14539 PyThreadState* __tstate = wxPyBeginAllowThreads();
14540 (arg1)->RotateHue(arg2);
14541
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 Py_INCREF(Py_None); resultobj = Py_None;
14546 return resultobj;
14547 fail:
14548 return NULL;
14549 }
14550
14551
14552 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14553 PyObject *resultobj = NULL;
14554 wxImage_RGBValue arg1 ;
14555 wxImage_HSVValue result;
14556 PyObject * obj0 = 0 ;
14557 char *kwnames[] = {
14558 (char *) "rgb", NULL
14559 };
14560
14561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14562 {
14563 wxImage_RGBValue * argp;
14564 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14565 if (SWIG_arg_fail(1)) SWIG_fail;
14566 if (argp == NULL) {
14567 SWIG_null_ref("wxImage_RGBValue");
14568 }
14569 if (SWIG_arg_fail(1)) SWIG_fail;
14570 arg1 = *argp;
14571 }
14572 {
14573 PyThreadState* __tstate = wxPyBeginAllowThreads();
14574 result = wxImage::RGBtoHSV(arg1);
14575
14576 wxPyEndAllowThreads(__tstate);
14577 if (PyErr_Occurred()) SWIG_fail;
14578 }
14579 {
14580 wxImage_HSVValue * resultptr;
14581 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14583 }
14584 return resultobj;
14585 fail:
14586 return NULL;
14587 }
14588
14589
14590 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14591 PyObject *resultobj = NULL;
14592 wxImage_HSVValue arg1 ;
14593 wxImage_RGBValue result;
14594 PyObject * obj0 = 0 ;
14595 char *kwnames[] = {
14596 (char *) "hsv", NULL
14597 };
14598
14599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14600 {
14601 wxImage_HSVValue * argp;
14602 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14603 if (SWIG_arg_fail(1)) SWIG_fail;
14604 if (argp == NULL) {
14605 SWIG_null_ref("wxImage_HSVValue");
14606 }
14607 if (SWIG_arg_fail(1)) SWIG_fail;
14608 arg1 = *argp;
14609 }
14610 {
14611 PyThreadState* __tstate = wxPyBeginAllowThreads();
14612 result = wxImage::HSVtoRGB(arg1);
14613
14614 wxPyEndAllowThreads(__tstate);
14615 if (PyErr_Occurred()) SWIG_fail;
14616 }
14617 {
14618 wxImage_RGBValue * resultptr;
14619 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14621 }
14622 return resultobj;
14623 fail:
14624 return NULL;
14625 }
14626
14627
14628 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14629 PyObject *obj;
14630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14631 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14632 Py_INCREF(obj);
14633 return Py_BuildValue((char *)"");
14634 }
14635 static int _wrap_NullImage_set(PyObject *) {
14636 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14637 return 1;
14638 }
14639
14640
14641 static PyObject *_wrap_NullImage_get(void) {
14642 PyObject *pyobj = NULL;
14643
14644 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14645 return pyobj;
14646 }
14647
14648
14649 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14650 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14651 return 1;
14652 }
14653
14654
14655 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14656 PyObject *pyobj = NULL;
14657
14658 {
14659 #if wxUSE_UNICODE
14660 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14661 #else
14662 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14663 #endif
14664 }
14665 return pyobj;
14666 }
14667
14668
14669 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14670 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14671 return 1;
14672 }
14673
14674
14675 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14676 PyObject *pyobj = NULL;
14677
14678 {
14679 #if wxUSE_UNICODE
14680 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14681 #else
14682 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14683 #endif
14684 }
14685 return pyobj;
14686 }
14687
14688
14689 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14690 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14691 return 1;
14692 }
14693
14694
14695 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14696 PyObject *pyobj = NULL;
14697
14698 {
14699 #if wxUSE_UNICODE
14700 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14701 #else
14702 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14703 #endif
14704 }
14705 return pyobj;
14706 }
14707
14708
14709 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14710 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14711 return 1;
14712 }
14713
14714
14715 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14716 PyObject *pyobj = NULL;
14717
14718 {
14719 #if wxUSE_UNICODE
14720 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14721 #else
14722 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14723 #endif
14724 }
14725 return pyobj;
14726 }
14727
14728
14729 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14730 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14731 return 1;
14732 }
14733
14734
14735 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14736 PyObject *pyobj = NULL;
14737
14738 {
14739 #if wxUSE_UNICODE
14740 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14741 #else
14742 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14743 #endif
14744 }
14745 return pyobj;
14746 }
14747
14748
14749 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14750 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14751 return 1;
14752 }
14753
14754
14755 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14756 PyObject *pyobj = NULL;
14757
14758 {
14759 #if wxUSE_UNICODE
14760 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14761 #else
14762 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14763 #endif
14764 }
14765 return pyobj;
14766 }
14767
14768
14769 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14770 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14771 return 1;
14772 }
14773
14774
14775 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14776 PyObject *pyobj = NULL;
14777
14778 {
14779 #if wxUSE_UNICODE
14780 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14781 #else
14782 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14783 #endif
14784 }
14785 return pyobj;
14786 }
14787
14788
14789 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14790 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14791 return 1;
14792 }
14793
14794
14795 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14796 PyObject *pyobj = NULL;
14797
14798 {
14799 #if wxUSE_UNICODE
14800 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14801 #else
14802 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14803 #endif
14804 }
14805 return pyobj;
14806 }
14807
14808
14809 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14810 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14811 return 1;
14812 }
14813
14814
14815 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14816 PyObject *pyobj = NULL;
14817
14818 {
14819 #if wxUSE_UNICODE
14820 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14821 #else
14822 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14823 #endif
14824 }
14825 return pyobj;
14826 }
14827
14828
14829 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14830 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14831 return 1;
14832 }
14833
14834
14835 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14836 PyObject *pyobj = NULL;
14837
14838 {
14839 #if wxUSE_UNICODE
14840 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14841 #else
14842 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14843 #endif
14844 }
14845 return pyobj;
14846 }
14847
14848
14849 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14850 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14851 return 1;
14852 }
14853
14854
14855 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14856 PyObject *pyobj = NULL;
14857
14858 {
14859 #if wxUSE_UNICODE
14860 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14861 #else
14862 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14863 #endif
14864 }
14865 return pyobj;
14866 }
14867
14868
14869 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14870 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14871 return 1;
14872 }
14873
14874
14875 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14876 PyObject *pyobj = NULL;
14877
14878 {
14879 #if wxUSE_UNICODE
14880 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14881 #else
14882 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14883 #endif
14884 }
14885 return pyobj;
14886 }
14887
14888
14889 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14890 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14891 return 1;
14892 }
14893
14894
14895 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14896 PyObject *pyobj = NULL;
14897
14898 {
14899 #if wxUSE_UNICODE
14900 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14901 #else
14902 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14903 #endif
14904 }
14905 return pyobj;
14906 }
14907
14908
14909 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14910 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14911 return 1;
14912 }
14913
14914
14915 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14916 PyObject *pyobj = NULL;
14917
14918 {
14919 #if wxUSE_UNICODE
14920 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14921 #else
14922 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14923 #endif
14924 }
14925 return pyobj;
14926 }
14927
14928
14929 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14930 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14931 return 1;
14932 }
14933
14934
14935 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14936 PyObject *pyobj = NULL;
14937
14938 {
14939 #if wxUSE_UNICODE
14940 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14941 #else
14942 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14943 #endif
14944 }
14945 return pyobj;
14946 }
14947
14948
14949 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj = NULL;
14951 wxBMPHandler *result;
14952 char *kwnames[] = {
14953 NULL
14954 };
14955
14956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 result = (wxBMPHandler *)new wxBMPHandler();
14960
14961 wxPyEndAllowThreads(__tstate);
14962 if (PyErr_Occurred()) SWIG_fail;
14963 }
14964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14965 return resultobj;
14966 fail:
14967 return NULL;
14968 }
14969
14970
14971 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14972 PyObject *obj;
14973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14974 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14975 Py_INCREF(obj);
14976 return Py_BuildValue((char *)"");
14977 }
14978 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14979 PyObject *resultobj = NULL;
14980 wxICOHandler *result;
14981 char *kwnames[] = {
14982 NULL
14983 };
14984
14985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14986 {
14987 PyThreadState* __tstate = wxPyBeginAllowThreads();
14988 result = (wxICOHandler *)new wxICOHandler();
14989
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14994 return resultobj;
14995 fail:
14996 return NULL;
14997 }
14998
14999
15000 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
15001 PyObject *obj;
15002 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15003 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
15004 Py_INCREF(obj);
15005 return Py_BuildValue((char *)"");
15006 }
15007 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15008 PyObject *resultobj = NULL;
15009 wxCURHandler *result;
15010 char *kwnames[] = {
15011 NULL
15012 };
15013
15014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
15015 {
15016 PyThreadState* __tstate = wxPyBeginAllowThreads();
15017 result = (wxCURHandler *)new wxCURHandler();
15018
15019 wxPyEndAllowThreads(__tstate);
15020 if (PyErr_Occurred()) SWIG_fail;
15021 }
15022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
15023 return resultobj;
15024 fail:
15025 return NULL;
15026 }
15027
15028
15029 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
15030 PyObject *obj;
15031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15032 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
15033 Py_INCREF(obj);
15034 return Py_BuildValue((char *)"");
15035 }
15036 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15037 PyObject *resultobj = NULL;
15038 wxANIHandler *result;
15039 char *kwnames[] = {
15040 NULL
15041 };
15042
15043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (wxANIHandler *)new wxANIHandler();
15047
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
15052 return resultobj;
15053 fail:
15054 return NULL;
15055 }
15056
15057
15058 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15059 PyObject *obj;
15060 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15061 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15062 Py_INCREF(obj);
15063 return Py_BuildValue((char *)"");
15064 }
15065 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15066 PyObject *resultobj = NULL;
15067 wxPNGHandler *result;
15068 char *kwnames[] = {
15069 NULL
15070 };
15071
15072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 result = (wxPNGHandler *)new wxPNGHandler();
15076
15077 wxPyEndAllowThreads(__tstate);
15078 if (PyErr_Occurred()) SWIG_fail;
15079 }
15080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15081 return resultobj;
15082 fail:
15083 return NULL;
15084 }
15085
15086
15087 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15088 PyObject *obj;
15089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15090 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15091 Py_INCREF(obj);
15092 return Py_BuildValue((char *)"");
15093 }
15094 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15095 PyObject *resultobj = NULL;
15096 wxGIFHandler *result;
15097 char *kwnames[] = {
15098 NULL
15099 };
15100
15101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 result = (wxGIFHandler *)new wxGIFHandler();
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15117 PyObject *obj;
15118 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15119 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15120 Py_INCREF(obj);
15121 return Py_BuildValue((char *)"");
15122 }
15123 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj = NULL;
15125 wxPCXHandler *result;
15126 char *kwnames[] = {
15127 NULL
15128 };
15129
15130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15131 {
15132 PyThreadState* __tstate = wxPyBeginAllowThreads();
15133 result = (wxPCXHandler *)new wxPCXHandler();
15134
15135 wxPyEndAllowThreads(__tstate);
15136 if (PyErr_Occurred()) SWIG_fail;
15137 }
15138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15139 return resultobj;
15140 fail:
15141 return NULL;
15142 }
15143
15144
15145 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15146 PyObject *obj;
15147 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15148 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15149 Py_INCREF(obj);
15150 return Py_BuildValue((char *)"");
15151 }
15152 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15153 PyObject *resultobj = NULL;
15154 wxJPEGHandler *result;
15155 char *kwnames[] = {
15156 NULL
15157 };
15158
15159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15160 {
15161 PyThreadState* __tstate = wxPyBeginAllowThreads();
15162 result = (wxJPEGHandler *)new wxJPEGHandler();
15163
15164 wxPyEndAllowThreads(__tstate);
15165 if (PyErr_Occurred()) SWIG_fail;
15166 }
15167 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15168 return resultobj;
15169 fail:
15170 return NULL;
15171 }
15172
15173
15174 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15175 PyObject *obj;
15176 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15177 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15178 Py_INCREF(obj);
15179 return Py_BuildValue((char *)"");
15180 }
15181 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15182 PyObject *resultobj = NULL;
15183 wxPNMHandler *result;
15184 char *kwnames[] = {
15185 NULL
15186 };
15187
15188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 result = (wxPNMHandler *)new wxPNMHandler();
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15204 PyObject *obj;
15205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15206 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15207 Py_INCREF(obj);
15208 return Py_BuildValue((char *)"");
15209 }
15210 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15211 PyObject *resultobj = NULL;
15212 wxXPMHandler *result;
15213 char *kwnames[] = {
15214 NULL
15215 };
15216
15217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15218 {
15219 PyThreadState* __tstate = wxPyBeginAllowThreads();
15220 result = (wxXPMHandler *)new wxXPMHandler();
15221
15222 wxPyEndAllowThreads(__tstate);
15223 if (PyErr_Occurred()) SWIG_fail;
15224 }
15225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15226 return resultobj;
15227 fail:
15228 return NULL;
15229 }
15230
15231
15232 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15233 PyObject *obj;
15234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15235 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15236 Py_INCREF(obj);
15237 return Py_BuildValue((char *)"");
15238 }
15239 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15240 PyObject *resultobj = NULL;
15241 wxTIFFHandler *result;
15242 char *kwnames[] = {
15243 NULL
15244 };
15245
15246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15247 {
15248 PyThreadState* __tstate = wxPyBeginAllowThreads();
15249 result = (wxTIFFHandler *)new wxTIFFHandler();
15250
15251 wxPyEndAllowThreads(__tstate);
15252 if (PyErr_Occurred()) SWIG_fail;
15253 }
15254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15255 return resultobj;
15256 fail:
15257 return NULL;
15258 }
15259
15260
15261 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15262 PyObject *obj;
15263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15264 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15265 Py_INCREF(obj);
15266 return Py_BuildValue((char *)"");
15267 }
15268 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15269 PyObject *resultobj = NULL;
15270 wxImage *arg1 = 0 ;
15271 wxImage *arg2 = 0 ;
15272 int arg3 = (int) 236 ;
15273 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15274 bool result;
15275 PyObject * obj0 = 0 ;
15276 PyObject * obj1 = 0 ;
15277 PyObject * obj2 = 0 ;
15278 PyObject * obj3 = 0 ;
15279 char *kwnames[] = {
15280 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15281 };
15282
15283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15284 {
15285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15286 if (SWIG_arg_fail(1)) SWIG_fail;
15287 if (arg1 == NULL) {
15288 SWIG_null_ref("wxImage");
15289 }
15290 if (SWIG_arg_fail(1)) SWIG_fail;
15291 }
15292 {
15293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15294 if (SWIG_arg_fail(2)) SWIG_fail;
15295 if (arg2 == NULL) {
15296 SWIG_null_ref("wxImage");
15297 }
15298 if (SWIG_arg_fail(2)) SWIG_fail;
15299 }
15300 if (obj2) {
15301 {
15302 arg3 = static_cast<int >(SWIG_As_int(obj2));
15303 if (SWIG_arg_fail(3)) SWIG_fail;
15304 }
15305 }
15306 if (obj3) {
15307 {
15308 arg4 = static_cast<int >(SWIG_As_int(obj3));
15309 if (SWIG_arg_fail(4)) SWIG_fail;
15310 }
15311 }
15312 {
15313 PyThreadState* __tstate = wxPyBeginAllowThreads();
15314 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15315
15316 wxPyEndAllowThreads(__tstate);
15317 if (PyErr_Occurred()) SWIG_fail;
15318 }
15319 {
15320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15321 }
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15329 PyObject *obj;
15330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15331 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15332 Py_INCREF(obj);
15333 return Py_BuildValue((char *)"");
15334 }
15335 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15336 PyObject *resultobj = NULL;
15337 wxEvtHandler *result;
15338 char *kwnames[] = {
15339 NULL
15340 };
15341
15342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 result = (wxEvtHandler *)new wxEvtHandler();
15346
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj = NULL;
15359 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15360 wxEvtHandler *result;
15361 PyObject * obj0 = 0 ;
15362 char *kwnames[] = {
15363 (char *) "self", NULL
15364 };
15365
15366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15368 if (SWIG_arg_fail(1)) SWIG_fail;
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15372
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 {
15377 resultobj = wxPyMake_wxObject(result, 0);
15378 }
15379 return resultobj;
15380 fail:
15381 return NULL;
15382 }
15383
15384
15385 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15386 PyObject *resultobj = NULL;
15387 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15388 wxEvtHandler *result;
15389 PyObject * obj0 = 0 ;
15390 char *kwnames[] = {
15391 (char *) "self", NULL
15392 };
15393
15394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(1)) SWIG_fail;
15397 {
15398 PyThreadState* __tstate = wxPyBeginAllowThreads();
15399 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15400
15401 wxPyEndAllowThreads(__tstate);
15402 if (PyErr_Occurred()) SWIG_fail;
15403 }
15404 {
15405 resultobj = wxPyMake_wxObject(result, 0);
15406 }
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15414 PyObject *resultobj = NULL;
15415 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15416 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15417 PyObject * obj0 = 0 ;
15418 PyObject * obj1 = 0 ;
15419 char *kwnames[] = {
15420 (char *) "self",(char *) "handler", NULL
15421 };
15422
15423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15425 if (SWIG_arg_fail(1)) SWIG_fail;
15426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15427 if (SWIG_arg_fail(2)) SWIG_fail;
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 (arg1)->SetNextHandler(arg2);
15431
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 Py_INCREF(Py_None); resultobj = Py_None;
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15443 PyObject *resultobj = NULL;
15444 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15445 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15446 PyObject * obj0 = 0 ;
15447 PyObject * obj1 = 0 ;
15448 char *kwnames[] = {
15449 (char *) "self",(char *) "handler", NULL
15450 };
15451
15452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15454 if (SWIG_arg_fail(1)) SWIG_fail;
15455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15456 if (SWIG_arg_fail(2)) SWIG_fail;
15457 {
15458 PyThreadState* __tstate = wxPyBeginAllowThreads();
15459 (arg1)->SetPreviousHandler(arg2);
15460
15461 wxPyEndAllowThreads(__tstate);
15462 if (PyErr_Occurred()) SWIG_fail;
15463 }
15464 Py_INCREF(Py_None); resultobj = Py_None;
15465 return resultobj;
15466 fail:
15467 return NULL;
15468 }
15469
15470
15471 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15472 PyObject *resultobj = NULL;
15473 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15474 bool result;
15475 PyObject * obj0 = 0 ;
15476 char *kwnames[] = {
15477 (char *) "self", NULL
15478 };
15479
15480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15482 if (SWIG_arg_fail(1)) SWIG_fail;
15483 {
15484 PyThreadState* __tstate = wxPyBeginAllowThreads();
15485 result = (bool)(arg1)->GetEvtHandlerEnabled();
15486
15487 wxPyEndAllowThreads(__tstate);
15488 if (PyErr_Occurred()) SWIG_fail;
15489 }
15490 {
15491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15492 }
15493 return resultobj;
15494 fail:
15495 return NULL;
15496 }
15497
15498
15499 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15500 PyObject *resultobj = NULL;
15501 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15502 bool arg2 ;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 char *kwnames[] = {
15506 (char *) "self",(char *) "enabled", NULL
15507 };
15508
15509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15511 if (SWIG_arg_fail(1)) SWIG_fail;
15512 {
15513 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15514 if (SWIG_arg_fail(2)) SWIG_fail;
15515 }
15516 {
15517 PyThreadState* __tstate = wxPyBeginAllowThreads();
15518 (arg1)->SetEvtHandlerEnabled(arg2);
15519
15520 wxPyEndAllowThreads(__tstate);
15521 if (PyErr_Occurred()) SWIG_fail;
15522 }
15523 Py_INCREF(Py_None); resultobj = Py_None;
15524 return resultobj;
15525 fail:
15526 return NULL;
15527 }
15528
15529
15530 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15531 PyObject *resultobj = NULL;
15532 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15533 wxEvent *arg2 = 0 ;
15534 bool result;
15535 PyObject * obj0 = 0 ;
15536 PyObject * obj1 = 0 ;
15537 char *kwnames[] = {
15538 (char *) "self",(char *) "event", NULL
15539 };
15540
15541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15543 if (SWIG_arg_fail(1)) SWIG_fail;
15544 {
15545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15546 if (SWIG_arg_fail(2)) SWIG_fail;
15547 if (arg2 == NULL) {
15548 SWIG_null_ref("wxEvent");
15549 }
15550 if (SWIG_arg_fail(2)) SWIG_fail;
15551 }
15552 {
15553 PyThreadState* __tstate = wxPyBeginAllowThreads();
15554 result = (bool)(arg1)->ProcessEvent(*arg2);
15555
15556 wxPyEndAllowThreads(__tstate);
15557 if (PyErr_Occurred()) SWIG_fail;
15558 }
15559 {
15560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15561 }
15562 return resultobj;
15563 fail:
15564 return NULL;
15565 }
15566
15567
15568 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15569 PyObject *resultobj = NULL;
15570 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15571 wxEvent *arg2 = 0 ;
15572 PyObject * obj0 = 0 ;
15573 PyObject * obj1 = 0 ;
15574 char *kwnames[] = {
15575 (char *) "self",(char *) "event", NULL
15576 };
15577
15578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15580 if (SWIG_arg_fail(1)) SWIG_fail;
15581 {
15582 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15583 if (SWIG_arg_fail(2)) SWIG_fail;
15584 if (arg2 == NULL) {
15585 SWIG_null_ref("wxEvent");
15586 }
15587 if (SWIG_arg_fail(2)) SWIG_fail;
15588 }
15589 {
15590 PyThreadState* __tstate = wxPyBeginAllowThreads();
15591 (arg1)->AddPendingEvent(*arg2);
15592
15593 wxPyEndAllowThreads(__tstate);
15594 if (PyErr_Occurred()) SWIG_fail;
15595 }
15596 Py_INCREF(Py_None); resultobj = Py_None;
15597 return resultobj;
15598 fail:
15599 return NULL;
15600 }
15601
15602
15603 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15604 PyObject *resultobj = NULL;
15605 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15606 PyObject * obj0 = 0 ;
15607 char *kwnames[] = {
15608 (char *) "self", NULL
15609 };
15610
15611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15613 if (SWIG_arg_fail(1)) SWIG_fail;
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 (arg1)->ProcessPendingEvents();
15617
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 Py_INCREF(Py_None); resultobj = Py_None;
15622 return resultobj;
15623 fail:
15624 return NULL;
15625 }
15626
15627
15628 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15629 PyObject *resultobj = NULL;
15630 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15631 int arg2 ;
15632 int arg3 ;
15633 int arg4 ;
15634 PyObject *arg5 = (PyObject *) 0 ;
15635 PyObject * obj0 = 0 ;
15636 PyObject * obj1 = 0 ;
15637 PyObject * obj2 = 0 ;
15638 PyObject * obj3 = 0 ;
15639 PyObject * obj4 = 0 ;
15640 char *kwnames[] = {
15641 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15642 };
15643
15644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15646 if (SWIG_arg_fail(1)) SWIG_fail;
15647 {
15648 arg2 = static_cast<int >(SWIG_As_int(obj1));
15649 if (SWIG_arg_fail(2)) SWIG_fail;
15650 }
15651 {
15652 arg3 = static_cast<int >(SWIG_As_int(obj2));
15653 if (SWIG_arg_fail(3)) SWIG_fail;
15654 }
15655 {
15656 arg4 = static_cast<int >(SWIG_As_int(obj3));
15657 if (SWIG_arg_fail(4)) SWIG_fail;
15658 }
15659 arg5 = obj4;
15660 {
15661 PyThreadState* __tstate = wxPyBeginAllowThreads();
15662 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15663
15664 wxPyEndAllowThreads(__tstate);
15665 if (PyErr_Occurred()) SWIG_fail;
15666 }
15667 Py_INCREF(Py_None); resultobj = Py_None;
15668 return resultobj;
15669 fail:
15670 return NULL;
15671 }
15672
15673
15674 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15675 PyObject *resultobj = NULL;
15676 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15677 int arg2 ;
15678 int arg3 = (int) -1 ;
15679 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15680 bool result;
15681 PyObject * obj0 = 0 ;
15682 PyObject * obj1 = 0 ;
15683 PyObject * obj2 = 0 ;
15684 PyObject * obj3 = 0 ;
15685 char *kwnames[] = {
15686 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15687 };
15688
15689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15691 if (SWIG_arg_fail(1)) SWIG_fail;
15692 {
15693 arg2 = static_cast<int >(SWIG_As_int(obj1));
15694 if (SWIG_arg_fail(2)) SWIG_fail;
15695 }
15696 if (obj2) {
15697 {
15698 arg3 = static_cast<int >(SWIG_As_int(obj2));
15699 if (SWIG_arg_fail(3)) SWIG_fail;
15700 }
15701 }
15702 if (obj3) {
15703 {
15704 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15705 if (SWIG_arg_fail(4)) SWIG_fail;
15706 }
15707 }
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15711
15712 wxPyEndAllowThreads(__tstate);
15713 if (PyErr_Occurred()) SWIG_fail;
15714 }
15715 {
15716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15717 }
15718 return resultobj;
15719 fail:
15720 return NULL;
15721 }
15722
15723
15724 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15725 PyObject *resultobj = NULL;
15726 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15727 PyObject *arg2 = (PyObject *) 0 ;
15728 bool arg3 = (bool) true ;
15729 PyObject * obj0 = 0 ;
15730 PyObject * obj1 = 0 ;
15731 PyObject * obj2 = 0 ;
15732 char *kwnames[] = {
15733 (char *) "self",(char *) "_self",(char *) "incref", NULL
15734 };
15735
15736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15738 if (SWIG_arg_fail(1)) SWIG_fail;
15739 arg2 = obj1;
15740 if (obj2) {
15741 {
15742 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15743 if (SWIG_arg_fail(3)) SWIG_fail;
15744 }
15745 }
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15749
15750 wxPyEndAllowThreads(__tstate);
15751 if (PyErr_Occurred()) SWIG_fail;
15752 }
15753 Py_INCREF(Py_None); resultobj = Py_None;
15754 return resultobj;
15755 fail:
15756 return NULL;
15757 }
15758
15759
15760 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15761 PyObject *obj;
15762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15763 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15764 Py_INCREF(obj);
15765 return Py_BuildValue((char *)"");
15766 }
15767 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15768 PyObject *resultobj = NULL;
15769 wxEventType result;
15770 char *kwnames[] = {
15771 NULL
15772 };
15773
15774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15775 {
15776 PyThreadState* __tstate = wxPyBeginAllowThreads();
15777 result = (wxEventType)wxNewEventType();
15778
15779 wxPyEndAllowThreads(__tstate);
15780 if (PyErr_Occurred()) SWIG_fail;
15781 }
15782 {
15783 resultobj = SWIG_From_int(static_cast<int >(result));
15784 }
15785 return resultobj;
15786 fail:
15787 return NULL;
15788 }
15789
15790
15791 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15792 PyObject *resultobj = NULL;
15793 wxEvent *arg1 = (wxEvent *) 0 ;
15794 PyObject * obj0 = 0 ;
15795 char *kwnames[] = {
15796 (char *) "self", NULL
15797 };
15798
15799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15801 if (SWIG_arg_fail(1)) SWIG_fail;
15802 {
15803 PyThreadState* __tstate = wxPyBeginAllowThreads();
15804 delete arg1;
15805
15806 wxPyEndAllowThreads(__tstate);
15807 if (PyErr_Occurred()) SWIG_fail;
15808 }
15809 Py_INCREF(Py_None); resultobj = Py_None;
15810 return resultobj;
15811 fail:
15812 return NULL;
15813 }
15814
15815
15816 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15817 PyObject *resultobj = NULL;
15818 wxEvent *arg1 = (wxEvent *) 0 ;
15819 wxEventType arg2 ;
15820 PyObject * obj0 = 0 ;
15821 PyObject * obj1 = 0 ;
15822 char *kwnames[] = {
15823 (char *) "self",(char *) "typ", NULL
15824 };
15825
15826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15828 if (SWIG_arg_fail(1)) SWIG_fail;
15829 {
15830 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15831 if (SWIG_arg_fail(2)) SWIG_fail;
15832 }
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 (arg1)->SetEventType(arg2);
15836
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 Py_INCREF(Py_None); resultobj = Py_None;
15841 return resultobj;
15842 fail:
15843 return NULL;
15844 }
15845
15846
15847 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15848 PyObject *resultobj = NULL;
15849 wxEvent *arg1 = (wxEvent *) 0 ;
15850 wxEventType result;
15851 PyObject * obj0 = 0 ;
15852 char *kwnames[] = {
15853 (char *) "self", NULL
15854 };
15855
15856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15858 if (SWIG_arg_fail(1)) SWIG_fail;
15859 {
15860 PyThreadState* __tstate = wxPyBeginAllowThreads();
15861 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15862
15863 wxPyEndAllowThreads(__tstate);
15864 if (PyErr_Occurred()) SWIG_fail;
15865 }
15866 {
15867 resultobj = SWIG_From_int(static_cast<int >(result));
15868 }
15869 return resultobj;
15870 fail:
15871 return NULL;
15872 }
15873
15874
15875 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15876 PyObject *resultobj = NULL;
15877 wxEvent *arg1 = (wxEvent *) 0 ;
15878 wxObject *result;
15879 PyObject * obj0 = 0 ;
15880 char *kwnames[] = {
15881 (char *) "self", NULL
15882 };
15883
15884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15886 if (SWIG_arg_fail(1)) SWIG_fail;
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15890
15891 wxPyEndAllowThreads(__tstate);
15892 if (PyErr_Occurred()) SWIG_fail;
15893 }
15894 {
15895 resultobj = wxPyMake_wxObject(result, (bool)0);
15896 }
15897 return resultobj;
15898 fail:
15899 return NULL;
15900 }
15901
15902
15903 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15904 PyObject *resultobj = NULL;
15905 wxEvent *arg1 = (wxEvent *) 0 ;
15906 wxObject *arg2 = (wxObject *) 0 ;
15907 PyObject * obj0 = 0 ;
15908 PyObject * obj1 = 0 ;
15909 char *kwnames[] = {
15910 (char *) "self",(char *) "obj", NULL
15911 };
15912
15913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15915 if (SWIG_arg_fail(1)) SWIG_fail;
15916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15917 if (SWIG_arg_fail(2)) SWIG_fail;
15918 {
15919 PyThreadState* __tstate = wxPyBeginAllowThreads();
15920 (arg1)->SetEventObject(arg2);
15921
15922 wxPyEndAllowThreads(__tstate);
15923 if (PyErr_Occurred()) SWIG_fail;
15924 }
15925 Py_INCREF(Py_None); resultobj = Py_None;
15926 return resultobj;
15927 fail:
15928 return NULL;
15929 }
15930
15931
15932 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15933 PyObject *resultobj = NULL;
15934 wxEvent *arg1 = (wxEvent *) 0 ;
15935 long result;
15936 PyObject * obj0 = 0 ;
15937 char *kwnames[] = {
15938 (char *) "self", NULL
15939 };
15940
15941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15943 if (SWIG_arg_fail(1)) SWIG_fail;
15944 {
15945 PyThreadState* __tstate = wxPyBeginAllowThreads();
15946 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15947
15948 wxPyEndAllowThreads(__tstate);
15949 if (PyErr_Occurred()) SWIG_fail;
15950 }
15951 {
15952 resultobj = SWIG_From_long(static_cast<long >(result));
15953 }
15954 return resultobj;
15955 fail:
15956 return NULL;
15957 }
15958
15959
15960 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15961 PyObject *resultobj = NULL;
15962 wxEvent *arg1 = (wxEvent *) 0 ;
15963 long arg2 = (long) 0 ;
15964 PyObject * obj0 = 0 ;
15965 PyObject * obj1 = 0 ;
15966 char *kwnames[] = {
15967 (char *) "self",(char *) "ts", NULL
15968 };
15969
15970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15972 if (SWIG_arg_fail(1)) SWIG_fail;
15973 if (obj1) {
15974 {
15975 arg2 = static_cast<long >(SWIG_As_long(obj1));
15976 if (SWIG_arg_fail(2)) SWIG_fail;
15977 }
15978 }
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 (arg1)->SetTimestamp(arg2);
15982
15983 wxPyEndAllowThreads(__tstate);
15984 if (PyErr_Occurred()) SWIG_fail;
15985 }
15986 Py_INCREF(Py_None); resultobj = Py_None;
15987 return resultobj;
15988 fail:
15989 return NULL;
15990 }
15991
15992
15993 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15994 PyObject *resultobj = NULL;
15995 wxEvent *arg1 = (wxEvent *) 0 ;
15996 int result;
15997 PyObject * obj0 = 0 ;
15998 char *kwnames[] = {
15999 (char *) "self", NULL
16000 };
16001
16002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
16003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16004 if (SWIG_arg_fail(1)) SWIG_fail;
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 result = (int)((wxEvent const *)arg1)->GetId();
16008
16009 wxPyEndAllowThreads(__tstate);
16010 if (PyErr_Occurred()) SWIG_fail;
16011 }
16012 {
16013 resultobj = SWIG_From_int(static_cast<int >(result));
16014 }
16015 return resultobj;
16016 fail:
16017 return NULL;
16018 }
16019
16020
16021 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
16022 PyObject *resultobj = NULL;
16023 wxEvent *arg1 = (wxEvent *) 0 ;
16024 int arg2 ;
16025 PyObject * obj0 = 0 ;
16026 PyObject * obj1 = 0 ;
16027 char *kwnames[] = {
16028 (char *) "self",(char *) "Id", NULL
16029 };
16030
16031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
16032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16033 if (SWIG_arg_fail(1)) SWIG_fail;
16034 {
16035 arg2 = static_cast<int >(SWIG_As_int(obj1));
16036 if (SWIG_arg_fail(2)) SWIG_fail;
16037 }
16038 {
16039 PyThreadState* __tstate = wxPyBeginAllowThreads();
16040 (arg1)->SetId(arg2);
16041
16042 wxPyEndAllowThreads(__tstate);
16043 if (PyErr_Occurred()) SWIG_fail;
16044 }
16045 Py_INCREF(Py_None); resultobj = Py_None;
16046 return resultobj;
16047 fail:
16048 return NULL;
16049 }
16050
16051
16052 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16053 PyObject *resultobj = NULL;
16054 wxEvent *arg1 = (wxEvent *) 0 ;
16055 bool result;
16056 PyObject * obj0 = 0 ;
16057 char *kwnames[] = {
16058 (char *) "self", NULL
16059 };
16060
16061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16063 if (SWIG_arg_fail(1)) SWIG_fail;
16064 {
16065 PyThreadState* __tstate = wxPyBeginAllowThreads();
16066 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16067
16068 wxPyEndAllowThreads(__tstate);
16069 if (PyErr_Occurred()) SWIG_fail;
16070 }
16071 {
16072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16073 }
16074 return resultobj;
16075 fail:
16076 return NULL;
16077 }
16078
16079
16080 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16081 PyObject *resultobj = NULL;
16082 wxEvent *arg1 = (wxEvent *) 0 ;
16083 bool arg2 = (bool) true ;
16084 PyObject * obj0 = 0 ;
16085 PyObject * obj1 = 0 ;
16086 char *kwnames[] = {
16087 (char *) "self",(char *) "skip", NULL
16088 };
16089
16090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16092 if (SWIG_arg_fail(1)) SWIG_fail;
16093 if (obj1) {
16094 {
16095 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16096 if (SWIG_arg_fail(2)) SWIG_fail;
16097 }
16098 }
16099 {
16100 PyThreadState* __tstate = wxPyBeginAllowThreads();
16101 (arg1)->Skip(arg2);
16102
16103 wxPyEndAllowThreads(__tstate);
16104 if (PyErr_Occurred()) SWIG_fail;
16105 }
16106 Py_INCREF(Py_None); resultobj = Py_None;
16107 return resultobj;
16108 fail:
16109 return NULL;
16110 }
16111
16112
16113 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16114 PyObject *resultobj = NULL;
16115 wxEvent *arg1 = (wxEvent *) 0 ;
16116 bool result;
16117 PyObject * obj0 = 0 ;
16118 char *kwnames[] = {
16119 (char *) "self", NULL
16120 };
16121
16122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
16123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16124 if (SWIG_arg_fail(1)) SWIG_fail;
16125 {
16126 PyThreadState* __tstate = wxPyBeginAllowThreads();
16127 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16128
16129 wxPyEndAllowThreads(__tstate);
16130 if (PyErr_Occurred()) SWIG_fail;
16131 }
16132 {
16133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16134 }
16135 return resultobj;
16136 fail:
16137 return NULL;
16138 }
16139
16140
16141 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16142 PyObject *resultobj = NULL;
16143 wxEvent *arg1 = (wxEvent *) 0 ;
16144 bool result;
16145 PyObject * obj0 = 0 ;
16146 char *kwnames[] = {
16147 (char *) "self", NULL
16148 };
16149
16150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16152 if (SWIG_arg_fail(1)) SWIG_fail;
16153 {
16154 PyThreadState* __tstate = wxPyBeginAllowThreads();
16155 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16156
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 {
16161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16162 }
16163 return resultobj;
16164 fail:
16165 return NULL;
16166 }
16167
16168
16169 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16170 PyObject *resultobj = NULL;
16171 wxEvent *arg1 = (wxEvent *) 0 ;
16172 int result;
16173 PyObject * obj0 = 0 ;
16174 char *kwnames[] = {
16175 (char *) "self", NULL
16176 };
16177
16178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16180 if (SWIG_arg_fail(1)) SWIG_fail;
16181 {
16182 PyThreadState* __tstate = wxPyBeginAllowThreads();
16183 result = (int)(arg1)->StopPropagation();
16184
16185 wxPyEndAllowThreads(__tstate);
16186 if (PyErr_Occurred()) SWIG_fail;
16187 }
16188 {
16189 resultobj = SWIG_From_int(static_cast<int >(result));
16190 }
16191 return resultobj;
16192 fail:
16193 return NULL;
16194 }
16195
16196
16197 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16198 PyObject *resultobj = NULL;
16199 wxEvent *arg1 = (wxEvent *) 0 ;
16200 int arg2 ;
16201 PyObject * obj0 = 0 ;
16202 PyObject * obj1 = 0 ;
16203 char *kwnames[] = {
16204 (char *) "self",(char *) "propagationLevel", NULL
16205 };
16206
16207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16209 if (SWIG_arg_fail(1)) SWIG_fail;
16210 {
16211 arg2 = static_cast<int >(SWIG_As_int(obj1));
16212 if (SWIG_arg_fail(2)) SWIG_fail;
16213 }
16214 {
16215 PyThreadState* __tstate = wxPyBeginAllowThreads();
16216 (arg1)->ResumePropagation(arg2);
16217
16218 wxPyEndAllowThreads(__tstate);
16219 if (PyErr_Occurred()) SWIG_fail;
16220 }
16221 Py_INCREF(Py_None); resultobj = Py_None;
16222 return resultobj;
16223 fail:
16224 return NULL;
16225 }
16226
16227
16228 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16229 PyObject *resultobj = NULL;
16230 wxEvent *arg1 = (wxEvent *) 0 ;
16231 wxEvent *result;
16232 PyObject * obj0 = 0 ;
16233 char *kwnames[] = {
16234 (char *) "self", NULL
16235 };
16236
16237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16239 if (SWIG_arg_fail(1)) SWIG_fail;
16240 {
16241 PyThreadState* __tstate = wxPyBeginAllowThreads();
16242 result = (wxEvent *)(arg1)->Clone();
16243
16244 wxPyEndAllowThreads(__tstate);
16245 if (PyErr_Occurred()) SWIG_fail;
16246 }
16247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16248 return resultobj;
16249 fail:
16250 return NULL;
16251 }
16252
16253
16254 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16255 PyObject *obj;
16256 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16257 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16258 Py_INCREF(obj);
16259 return Py_BuildValue((char *)"");
16260 }
16261 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj = NULL;
16263 wxEvent *arg1 = 0 ;
16264 wxPropagationDisabler *result;
16265 PyObject * obj0 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "event", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16271 {
16272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16273 if (SWIG_arg_fail(1)) SWIG_fail;
16274 if (arg1 == NULL) {
16275 SWIG_null_ref("wxEvent");
16276 }
16277 if (SWIG_arg_fail(1)) SWIG_fail;
16278 }
16279 {
16280 PyThreadState* __tstate = wxPyBeginAllowThreads();
16281 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16282
16283 wxPyEndAllowThreads(__tstate);
16284 if (PyErr_Occurred()) SWIG_fail;
16285 }
16286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16287 return resultobj;
16288 fail:
16289 return NULL;
16290 }
16291
16292
16293 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16294 PyObject *resultobj = NULL;
16295 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16296 PyObject * obj0 = 0 ;
16297 char *kwnames[] = {
16298 (char *) "self", NULL
16299 };
16300
16301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16303 if (SWIG_arg_fail(1)) SWIG_fail;
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 delete arg1;
16307
16308 wxPyEndAllowThreads(__tstate);
16309 if (PyErr_Occurred()) SWIG_fail;
16310 }
16311 Py_INCREF(Py_None); resultobj = Py_None;
16312 return resultobj;
16313 fail:
16314 return NULL;
16315 }
16316
16317
16318 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16319 PyObject *obj;
16320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16321 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16322 Py_INCREF(obj);
16323 return Py_BuildValue((char *)"");
16324 }
16325 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = NULL;
16327 wxEvent *arg1 = 0 ;
16328 wxPropagateOnce *result;
16329 PyObject * obj0 = 0 ;
16330 char *kwnames[] = {
16331 (char *) "event", NULL
16332 };
16333
16334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16335 {
16336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16337 if (SWIG_arg_fail(1)) SWIG_fail;
16338 if (arg1 == NULL) {
16339 SWIG_null_ref("wxEvent");
16340 }
16341 if (SWIG_arg_fail(1)) SWIG_fail;
16342 }
16343 {
16344 PyThreadState* __tstate = wxPyBeginAllowThreads();
16345 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16346
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = NULL;
16359 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16360 PyObject * obj0 = 0 ;
16361 char *kwnames[] = {
16362 (char *) "self", NULL
16363 };
16364
16365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16367 if (SWIG_arg_fail(1)) SWIG_fail;
16368 {
16369 PyThreadState* __tstate = wxPyBeginAllowThreads();
16370 delete arg1;
16371
16372 wxPyEndAllowThreads(__tstate);
16373 if (PyErr_Occurred()) SWIG_fail;
16374 }
16375 Py_INCREF(Py_None); resultobj = Py_None;
16376 return resultobj;
16377 fail:
16378 return NULL;
16379 }
16380
16381
16382 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16383 PyObject *obj;
16384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16385 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16386 Py_INCREF(obj);
16387 return Py_BuildValue((char *)"");
16388 }
16389 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16390 PyObject *resultobj = NULL;
16391 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16392 int arg2 = (int) 0 ;
16393 wxCommandEvent *result;
16394 PyObject * obj0 = 0 ;
16395 PyObject * obj1 = 0 ;
16396 char *kwnames[] = {
16397 (char *) "commandType",(char *) "winid", NULL
16398 };
16399
16400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16401 if (obj0) {
16402 {
16403 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16404 if (SWIG_arg_fail(1)) SWIG_fail;
16405 }
16406 }
16407 if (obj1) {
16408 {
16409 arg2 = static_cast<int >(SWIG_As_int(obj1));
16410 if (SWIG_arg_fail(2)) SWIG_fail;
16411 }
16412 }
16413 {
16414 PyThreadState* __tstate = wxPyBeginAllowThreads();
16415 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16416
16417 wxPyEndAllowThreads(__tstate);
16418 if (PyErr_Occurred()) SWIG_fail;
16419 }
16420 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16421 return resultobj;
16422 fail:
16423 return NULL;
16424 }
16425
16426
16427 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16428 PyObject *resultobj = NULL;
16429 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16430 int result;
16431 PyObject * obj0 = 0 ;
16432 char *kwnames[] = {
16433 (char *) "self", NULL
16434 };
16435
16436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16438 if (SWIG_arg_fail(1)) SWIG_fail;
16439 {
16440 PyThreadState* __tstate = wxPyBeginAllowThreads();
16441 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16442
16443 wxPyEndAllowThreads(__tstate);
16444 if (PyErr_Occurred()) SWIG_fail;
16445 }
16446 {
16447 resultobj = SWIG_From_int(static_cast<int >(result));
16448 }
16449 return resultobj;
16450 fail:
16451 return NULL;
16452 }
16453
16454
16455 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16456 PyObject *resultobj = NULL;
16457 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16458 wxString *arg2 = 0 ;
16459 bool temp2 = false ;
16460 PyObject * obj0 = 0 ;
16461 PyObject * obj1 = 0 ;
16462 char *kwnames[] = {
16463 (char *) "self",(char *) "s", NULL
16464 };
16465
16466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16468 if (SWIG_arg_fail(1)) SWIG_fail;
16469 {
16470 arg2 = wxString_in_helper(obj1);
16471 if (arg2 == NULL) SWIG_fail;
16472 temp2 = true;
16473 }
16474 {
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 (arg1)->SetString((wxString const &)*arg2);
16477
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 Py_INCREF(Py_None); resultobj = Py_None;
16482 {
16483 if (temp2)
16484 delete arg2;
16485 }
16486 return resultobj;
16487 fail:
16488 {
16489 if (temp2)
16490 delete arg2;
16491 }
16492 return NULL;
16493 }
16494
16495
16496 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16497 PyObject *resultobj = NULL;
16498 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16499 wxString result;
16500 PyObject * obj0 = 0 ;
16501 char *kwnames[] = {
16502 (char *) "self", NULL
16503 };
16504
16505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16507 if (SWIG_arg_fail(1)) SWIG_fail;
16508 {
16509 PyThreadState* __tstate = wxPyBeginAllowThreads();
16510 result = ((wxCommandEvent const *)arg1)->GetString();
16511
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 {
16516 #if wxUSE_UNICODE
16517 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16518 #else
16519 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16520 #endif
16521 }
16522 return resultobj;
16523 fail:
16524 return NULL;
16525 }
16526
16527
16528 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16529 PyObject *resultobj = NULL;
16530 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16531 bool result;
16532 PyObject * obj0 = 0 ;
16533 char *kwnames[] = {
16534 (char *) "self", NULL
16535 };
16536
16537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16539 if (SWIG_arg_fail(1)) SWIG_fail;
16540 {
16541 PyThreadState* __tstate = wxPyBeginAllowThreads();
16542 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16543
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 {
16548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16549 }
16550 return resultobj;
16551 fail:
16552 return NULL;
16553 }
16554
16555
16556 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16557 PyObject *resultobj = NULL;
16558 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16559 bool result;
16560 PyObject * obj0 = 0 ;
16561 char *kwnames[] = {
16562 (char *) "self", NULL
16563 };
16564
16565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16567 if (SWIG_arg_fail(1)) SWIG_fail;
16568 {
16569 PyThreadState* __tstate = wxPyBeginAllowThreads();
16570 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16571
16572 wxPyEndAllowThreads(__tstate);
16573 if (PyErr_Occurred()) SWIG_fail;
16574 }
16575 {
16576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16577 }
16578 return resultobj;
16579 fail:
16580 return NULL;
16581 }
16582
16583
16584 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16585 PyObject *resultobj = NULL;
16586 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16587 long arg2 ;
16588 PyObject * obj0 = 0 ;
16589 PyObject * obj1 = 0 ;
16590 char *kwnames[] = {
16591 (char *) "self",(char *) "extraLong", NULL
16592 };
16593
16594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16596 if (SWIG_arg_fail(1)) SWIG_fail;
16597 {
16598 arg2 = static_cast<long >(SWIG_As_long(obj1));
16599 if (SWIG_arg_fail(2)) SWIG_fail;
16600 }
16601 {
16602 PyThreadState* __tstate = wxPyBeginAllowThreads();
16603 (arg1)->SetExtraLong(arg2);
16604
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 Py_INCREF(Py_None); resultobj = Py_None;
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj = NULL;
16617 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16618 long result;
16619 PyObject * obj0 = 0 ;
16620 char *kwnames[] = {
16621 (char *) "self", NULL
16622 };
16623
16624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16626 if (SWIG_arg_fail(1)) SWIG_fail;
16627 {
16628 PyThreadState* __tstate = wxPyBeginAllowThreads();
16629 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16630
16631 wxPyEndAllowThreads(__tstate);
16632 if (PyErr_Occurred()) SWIG_fail;
16633 }
16634 {
16635 resultobj = SWIG_From_long(static_cast<long >(result));
16636 }
16637 return resultobj;
16638 fail:
16639 return NULL;
16640 }
16641
16642
16643 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16644 PyObject *resultobj = NULL;
16645 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16646 int arg2 ;
16647 PyObject * obj0 = 0 ;
16648 PyObject * obj1 = 0 ;
16649 char *kwnames[] = {
16650 (char *) "self",(char *) "i", NULL
16651 };
16652
16653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16655 if (SWIG_arg_fail(1)) SWIG_fail;
16656 {
16657 arg2 = static_cast<int >(SWIG_As_int(obj1));
16658 if (SWIG_arg_fail(2)) SWIG_fail;
16659 }
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 (arg1)->SetInt(arg2);
16663
16664 wxPyEndAllowThreads(__tstate);
16665 if (PyErr_Occurred()) SWIG_fail;
16666 }
16667 Py_INCREF(Py_None); resultobj = Py_None;
16668 return resultobj;
16669 fail:
16670 return NULL;
16671 }
16672
16673
16674 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16675 PyObject *resultobj = NULL;
16676 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16677 long result;
16678 PyObject * obj0 = 0 ;
16679 char *kwnames[] = {
16680 (char *) "self", NULL
16681 };
16682
16683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16685 if (SWIG_arg_fail(1)) SWIG_fail;
16686 {
16687 PyThreadState* __tstate = wxPyBeginAllowThreads();
16688 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16689
16690 wxPyEndAllowThreads(__tstate);
16691 if (PyErr_Occurred()) SWIG_fail;
16692 }
16693 {
16694 resultobj = SWIG_From_long(static_cast<long >(result));
16695 }
16696 return resultobj;
16697 fail:
16698 return NULL;
16699 }
16700
16701
16702 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16703 PyObject *resultobj = NULL;
16704 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16705 wxEvent *result;
16706 PyObject * obj0 = 0 ;
16707 char *kwnames[] = {
16708 (char *) "self", NULL
16709 };
16710
16711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16713 if (SWIG_arg_fail(1)) SWIG_fail;
16714 {
16715 PyThreadState* __tstate = wxPyBeginAllowThreads();
16716 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16717
16718 wxPyEndAllowThreads(__tstate);
16719 if (PyErr_Occurred()) SWIG_fail;
16720 }
16721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16722 return resultobj;
16723 fail:
16724 return NULL;
16725 }
16726
16727
16728 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16729 PyObject *obj;
16730 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16731 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16732 Py_INCREF(obj);
16733 return Py_BuildValue((char *)"");
16734 }
16735 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16736 PyObject *resultobj = NULL;
16737 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16738 int arg2 = (int) 0 ;
16739 wxNotifyEvent *result;
16740 PyObject * obj0 = 0 ;
16741 PyObject * obj1 = 0 ;
16742 char *kwnames[] = {
16743 (char *) "commandType",(char *) "winid", NULL
16744 };
16745
16746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16747 if (obj0) {
16748 {
16749 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16750 if (SWIG_arg_fail(1)) SWIG_fail;
16751 }
16752 }
16753 if (obj1) {
16754 {
16755 arg2 = static_cast<int >(SWIG_As_int(obj1));
16756 if (SWIG_arg_fail(2)) SWIG_fail;
16757 }
16758 }
16759 {
16760 PyThreadState* __tstate = wxPyBeginAllowThreads();
16761 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16762
16763 wxPyEndAllowThreads(__tstate);
16764 if (PyErr_Occurred()) SWIG_fail;
16765 }
16766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16767 return resultobj;
16768 fail:
16769 return NULL;
16770 }
16771
16772
16773 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16774 PyObject *resultobj = NULL;
16775 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16776 PyObject * obj0 = 0 ;
16777 char *kwnames[] = {
16778 (char *) "self", NULL
16779 };
16780
16781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16783 if (SWIG_arg_fail(1)) SWIG_fail;
16784 {
16785 PyThreadState* __tstate = wxPyBeginAllowThreads();
16786 (arg1)->Veto();
16787
16788 wxPyEndAllowThreads(__tstate);
16789 if (PyErr_Occurred()) SWIG_fail;
16790 }
16791 Py_INCREF(Py_None); resultobj = Py_None;
16792 return resultobj;
16793 fail:
16794 return NULL;
16795 }
16796
16797
16798 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16799 PyObject *resultobj = NULL;
16800 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16801 PyObject * obj0 = 0 ;
16802 char *kwnames[] = {
16803 (char *) "self", NULL
16804 };
16805
16806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16808 if (SWIG_arg_fail(1)) SWIG_fail;
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 (arg1)->Allow();
16812
16813 wxPyEndAllowThreads(__tstate);
16814 if (PyErr_Occurred()) SWIG_fail;
16815 }
16816 Py_INCREF(Py_None); resultobj = Py_None;
16817 return resultobj;
16818 fail:
16819 return NULL;
16820 }
16821
16822
16823 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16824 PyObject *resultobj = NULL;
16825 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16826 bool result;
16827 PyObject * obj0 = 0 ;
16828 char *kwnames[] = {
16829 (char *) "self", NULL
16830 };
16831
16832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16834 if (SWIG_arg_fail(1)) SWIG_fail;
16835 {
16836 PyThreadState* __tstate = wxPyBeginAllowThreads();
16837 result = (bool)(arg1)->IsAllowed();
16838
16839 wxPyEndAllowThreads(__tstate);
16840 if (PyErr_Occurred()) SWIG_fail;
16841 }
16842 {
16843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16844 }
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16852 PyObject *obj;
16853 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16854 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16855 Py_INCREF(obj);
16856 return Py_BuildValue((char *)"");
16857 }
16858 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16859 PyObject *resultobj = NULL;
16860 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16861 int arg2 = (int) 0 ;
16862 int arg3 = (int) 0 ;
16863 int arg4 = (int) 0 ;
16864 wxScrollEvent *result;
16865 PyObject * obj0 = 0 ;
16866 PyObject * obj1 = 0 ;
16867 PyObject * obj2 = 0 ;
16868 PyObject * obj3 = 0 ;
16869 char *kwnames[] = {
16870 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16871 };
16872
16873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16874 if (obj0) {
16875 {
16876 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16877 if (SWIG_arg_fail(1)) SWIG_fail;
16878 }
16879 }
16880 if (obj1) {
16881 {
16882 arg2 = static_cast<int >(SWIG_As_int(obj1));
16883 if (SWIG_arg_fail(2)) SWIG_fail;
16884 }
16885 }
16886 if (obj2) {
16887 {
16888 arg3 = static_cast<int >(SWIG_As_int(obj2));
16889 if (SWIG_arg_fail(3)) SWIG_fail;
16890 }
16891 }
16892 if (obj3) {
16893 {
16894 arg4 = static_cast<int >(SWIG_As_int(obj3));
16895 if (SWIG_arg_fail(4)) SWIG_fail;
16896 }
16897 }
16898 {
16899 PyThreadState* __tstate = wxPyBeginAllowThreads();
16900 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16901
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16906 return resultobj;
16907 fail:
16908 return NULL;
16909 }
16910
16911
16912 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16913 PyObject *resultobj = NULL;
16914 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16915 int result;
16916 PyObject * obj0 = 0 ;
16917 char *kwnames[] = {
16918 (char *) "self", NULL
16919 };
16920
16921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16923 if (SWIG_arg_fail(1)) SWIG_fail;
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16927
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 {
16932 resultobj = SWIG_From_int(static_cast<int >(result));
16933 }
16934 return resultobj;
16935 fail:
16936 return NULL;
16937 }
16938
16939
16940 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16941 PyObject *resultobj = NULL;
16942 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16943 int result;
16944 PyObject * obj0 = 0 ;
16945 char *kwnames[] = {
16946 (char *) "self", NULL
16947 };
16948
16949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16951 if (SWIG_arg_fail(1)) SWIG_fail;
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16955
16956 wxPyEndAllowThreads(__tstate);
16957 if (PyErr_Occurred()) SWIG_fail;
16958 }
16959 {
16960 resultobj = SWIG_From_int(static_cast<int >(result));
16961 }
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16969 PyObject *resultobj = NULL;
16970 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16971 int arg2 ;
16972 PyObject * obj0 = 0 ;
16973 PyObject * obj1 = 0 ;
16974 char *kwnames[] = {
16975 (char *) "self",(char *) "orient", NULL
16976 };
16977
16978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16980 if (SWIG_arg_fail(1)) SWIG_fail;
16981 {
16982 arg2 = static_cast<int >(SWIG_As_int(obj1));
16983 if (SWIG_arg_fail(2)) SWIG_fail;
16984 }
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 (arg1)->SetOrientation(arg2);
16988
16989 wxPyEndAllowThreads(__tstate);
16990 if (PyErr_Occurred()) SWIG_fail;
16991 }
16992 Py_INCREF(Py_None); resultobj = Py_None;
16993 return resultobj;
16994 fail:
16995 return NULL;
16996 }
16997
16998
16999 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17000 PyObject *resultobj = NULL;
17001 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
17002 int arg2 ;
17003 PyObject * obj0 = 0 ;
17004 PyObject * obj1 = 0 ;
17005 char *kwnames[] = {
17006 (char *) "self",(char *) "pos", NULL
17007 };
17008
17009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
17011 if (SWIG_arg_fail(1)) SWIG_fail;
17012 {
17013 arg2 = static_cast<int >(SWIG_As_int(obj1));
17014 if (SWIG_arg_fail(2)) SWIG_fail;
17015 }
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 (arg1)->SetPosition(arg2);
17019
17020 wxPyEndAllowThreads(__tstate);
17021 if (PyErr_Occurred()) SWIG_fail;
17022 }
17023 Py_INCREF(Py_None); resultobj = Py_None;
17024 return resultobj;
17025 fail:
17026 return NULL;
17027 }
17028
17029
17030 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
17031 PyObject *obj;
17032 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17033 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
17034 Py_INCREF(obj);
17035 return Py_BuildValue((char *)"");
17036 }
17037 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17038 PyObject *resultobj = NULL;
17039 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17040 int arg2 = (int) 0 ;
17041 int arg3 = (int) 0 ;
17042 wxScrollWinEvent *result;
17043 PyObject * obj0 = 0 ;
17044 PyObject * obj1 = 0 ;
17045 PyObject * obj2 = 0 ;
17046 char *kwnames[] = {
17047 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
17048 };
17049
17050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
17051 if (obj0) {
17052 {
17053 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17054 if (SWIG_arg_fail(1)) SWIG_fail;
17055 }
17056 }
17057 if (obj1) {
17058 {
17059 arg2 = static_cast<int >(SWIG_As_int(obj1));
17060 if (SWIG_arg_fail(2)) SWIG_fail;
17061 }
17062 }
17063 if (obj2) {
17064 {
17065 arg3 = static_cast<int >(SWIG_As_int(obj2));
17066 if (SWIG_arg_fail(3)) SWIG_fail;
17067 }
17068 }
17069 {
17070 PyThreadState* __tstate = wxPyBeginAllowThreads();
17071 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17072
17073 wxPyEndAllowThreads(__tstate);
17074 if (PyErr_Occurred()) SWIG_fail;
17075 }
17076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17077 return resultobj;
17078 fail:
17079 return NULL;
17080 }
17081
17082
17083 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17084 PyObject *resultobj = NULL;
17085 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17086 int result;
17087 PyObject * obj0 = 0 ;
17088 char *kwnames[] = {
17089 (char *) "self", NULL
17090 };
17091
17092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17094 if (SWIG_arg_fail(1)) SWIG_fail;
17095 {
17096 PyThreadState* __tstate = wxPyBeginAllowThreads();
17097 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17098
17099 wxPyEndAllowThreads(__tstate);
17100 if (PyErr_Occurred()) SWIG_fail;
17101 }
17102 {
17103 resultobj = SWIG_From_int(static_cast<int >(result));
17104 }
17105 return resultobj;
17106 fail:
17107 return NULL;
17108 }
17109
17110
17111 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17112 PyObject *resultobj = NULL;
17113 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17114 int result;
17115 PyObject * obj0 = 0 ;
17116 char *kwnames[] = {
17117 (char *) "self", NULL
17118 };
17119
17120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17122 if (SWIG_arg_fail(1)) SWIG_fail;
17123 {
17124 PyThreadState* __tstate = wxPyBeginAllowThreads();
17125 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17126
17127 wxPyEndAllowThreads(__tstate);
17128 if (PyErr_Occurred()) SWIG_fail;
17129 }
17130 {
17131 resultobj = SWIG_From_int(static_cast<int >(result));
17132 }
17133 return resultobj;
17134 fail:
17135 return NULL;
17136 }
17137
17138
17139 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17140 PyObject *resultobj = NULL;
17141 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17142 int arg2 ;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 char *kwnames[] = {
17146 (char *) "self",(char *) "orient", NULL
17147 };
17148
17149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17151 if (SWIG_arg_fail(1)) SWIG_fail;
17152 {
17153 arg2 = static_cast<int >(SWIG_As_int(obj1));
17154 if (SWIG_arg_fail(2)) SWIG_fail;
17155 }
17156 {
17157 PyThreadState* __tstate = wxPyBeginAllowThreads();
17158 (arg1)->SetOrientation(arg2);
17159
17160 wxPyEndAllowThreads(__tstate);
17161 if (PyErr_Occurred()) SWIG_fail;
17162 }
17163 Py_INCREF(Py_None); resultobj = Py_None;
17164 return resultobj;
17165 fail:
17166 return NULL;
17167 }
17168
17169
17170 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17171 PyObject *resultobj = NULL;
17172 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17173 int arg2 ;
17174 PyObject * obj0 = 0 ;
17175 PyObject * obj1 = 0 ;
17176 char *kwnames[] = {
17177 (char *) "self",(char *) "pos", NULL
17178 };
17179
17180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17182 if (SWIG_arg_fail(1)) SWIG_fail;
17183 {
17184 arg2 = static_cast<int >(SWIG_As_int(obj1));
17185 if (SWIG_arg_fail(2)) SWIG_fail;
17186 }
17187 {
17188 PyThreadState* __tstate = wxPyBeginAllowThreads();
17189 (arg1)->SetPosition(arg2);
17190
17191 wxPyEndAllowThreads(__tstate);
17192 if (PyErr_Occurred()) SWIG_fail;
17193 }
17194 Py_INCREF(Py_None); resultobj = Py_None;
17195 return resultobj;
17196 fail:
17197 return NULL;
17198 }
17199
17200
17201 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17202 PyObject *obj;
17203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17204 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17205 Py_INCREF(obj);
17206 return Py_BuildValue((char *)"");
17207 }
17208 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17209 PyObject *resultobj = NULL;
17210 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17211 wxMouseEvent *result;
17212 PyObject * obj0 = 0 ;
17213 char *kwnames[] = {
17214 (char *) "mouseType", NULL
17215 };
17216
17217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17218 if (obj0) {
17219 {
17220 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 }
17223 }
17224 {
17225 PyThreadState* __tstate = wxPyBeginAllowThreads();
17226 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17227
17228 wxPyEndAllowThreads(__tstate);
17229 if (PyErr_Occurred()) SWIG_fail;
17230 }
17231 {
17232 resultobj = wxPyMake_wxObject(result, (bool)1);
17233 }
17234 return resultobj;
17235 fail:
17236 return NULL;
17237 }
17238
17239
17240 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17241 PyObject *resultobj = NULL;
17242 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17243 bool result;
17244 PyObject * obj0 = 0 ;
17245 char *kwnames[] = {
17246 (char *) "self", NULL
17247 };
17248
17249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17251 if (SWIG_arg_fail(1)) SWIG_fail;
17252 {
17253 PyThreadState* __tstate = wxPyBeginAllowThreads();
17254 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17255
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 {
17260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17261 }
17262 return resultobj;
17263 fail:
17264 return NULL;
17265 }
17266
17267
17268 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17269 PyObject *resultobj = NULL;
17270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17271 int arg2 = (int) wxMOUSE_BTN_ANY ;
17272 bool result;
17273 PyObject * obj0 = 0 ;
17274 PyObject * obj1 = 0 ;
17275 char *kwnames[] = {
17276 (char *) "self",(char *) "but", NULL
17277 };
17278
17279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17281 if (SWIG_arg_fail(1)) SWIG_fail;
17282 if (obj1) {
17283 {
17284 arg2 = static_cast<int >(SWIG_As_int(obj1));
17285 if (SWIG_arg_fail(2)) SWIG_fail;
17286 }
17287 }
17288 {
17289 PyThreadState* __tstate = wxPyBeginAllowThreads();
17290 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17291
17292 wxPyEndAllowThreads(__tstate);
17293 if (PyErr_Occurred()) SWIG_fail;
17294 }
17295 {
17296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17297 }
17298 return resultobj;
17299 fail:
17300 return NULL;
17301 }
17302
17303
17304 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17305 PyObject *resultobj = NULL;
17306 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17307 int arg2 = (int) wxMOUSE_BTN_ANY ;
17308 bool result;
17309 PyObject * obj0 = 0 ;
17310 PyObject * obj1 = 0 ;
17311 char *kwnames[] = {
17312 (char *) "self",(char *) "but", NULL
17313 };
17314
17315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17317 if (SWIG_arg_fail(1)) SWIG_fail;
17318 if (obj1) {
17319 {
17320 arg2 = static_cast<int >(SWIG_As_int(obj1));
17321 if (SWIG_arg_fail(2)) SWIG_fail;
17322 }
17323 }
17324 {
17325 PyThreadState* __tstate = wxPyBeginAllowThreads();
17326 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17327
17328 wxPyEndAllowThreads(__tstate);
17329 if (PyErr_Occurred()) SWIG_fail;
17330 }
17331 {
17332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17333 }
17334 return resultobj;
17335 fail:
17336 return NULL;
17337 }
17338
17339
17340 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17341 PyObject *resultobj = NULL;
17342 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17343 int arg2 = (int) wxMOUSE_BTN_ANY ;
17344 bool result;
17345 PyObject * obj0 = 0 ;
17346 PyObject * obj1 = 0 ;
17347 char *kwnames[] = {
17348 (char *) "self",(char *) "but", NULL
17349 };
17350
17351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17353 if (SWIG_arg_fail(1)) SWIG_fail;
17354 if (obj1) {
17355 {
17356 arg2 = static_cast<int >(SWIG_As_int(obj1));
17357 if (SWIG_arg_fail(2)) SWIG_fail;
17358 }
17359 }
17360 {
17361 PyThreadState* __tstate = wxPyBeginAllowThreads();
17362 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17363
17364 wxPyEndAllowThreads(__tstate);
17365 if (PyErr_Occurred()) SWIG_fail;
17366 }
17367 {
17368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17369 }
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17377 PyObject *resultobj = NULL;
17378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17379 int arg2 ;
17380 bool result;
17381 PyObject * obj0 = 0 ;
17382 PyObject * obj1 = 0 ;
17383 char *kwnames[] = {
17384 (char *) "self",(char *) "button", NULL
17385 };
17386
17387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17389 if (SWIG_arg_fail(1)) SWIG_fail;
17390 {
17391 arg2 = static_cast<int >(SWIG_As_int(obj1));
17392 if (SWIG_arg_fail(2)) SWIG_fail;
17393 }
17394 {
17395 PyThreadState* __tstate = wxPyBeginAllowThreads();
17396 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17397
17398 wxPyEndAllowThreads(__tstate);
17399 if (PyErr_Occurred()) SWIG_fail;
17400 }
17401 {
17402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17403 }
17404 return resultobj;
17405 fail:
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj = NULL;
17412 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17413 int arg2 ;
17414 bool result;
17415 PyObject * obj0 = 0 ;
17416 PyObject * obj1 = 0 ;
17417 char *kwnames[] = {
17418 (char *) "self",(char *) "but", NULL
17419 };
17420
17421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17423 if (SWIG_arg_fail(1)) SWIG_fail;
17424 {
17425 arg2 = static_cast<int >(SWIG_As_int(obj1));
17426 if (SWIG_arg_fail(2)) SWIG_fail;
17427 }
17428 {
17429 PyThreadState* __tstate = wxPyBeginAllowThreads();
17430 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17431
17432 wxPyEndAllowThreads(__tstate);
17433 if (PyErr_Occurred()) SWIG_fail;
17434 }
17435 {
17436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17437 }
17438 return resultobj;
17439 fail:
17440 return NULL;
17441 }
17442
17443
17444 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17445 PyObject *resultobj = NULL;
17446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17447 int result;
17448 PyObject * obj0 = 0 ;
17449 char *kwnames[] = {
17450 (char *) "self", NULL
17451 };
17452
17453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17455 if (SWIG_arg_fail(1)) SWIG_fail;
17456 {
17457 PyThreadState* __tstate = wxPyBeginAllowThreads();
17458 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17459
17460 wxPyEndAllowThreads(__tstate);
17461 if (PyErr_Occurred()) SWIG_fail;
17462 }
17463 {
17464 resultobj = SWIG_From_int(static_cast<int >(result));
17465 }
17466 return resultobj;
17467 fail:
17468 return NULL;
17469 }
17470
17471
17472 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17473 PyObject *resultobj = NULL;
17474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17475 bool result;
17476 PyObject * obj0 = 0 ;
17477 char *kwnames[] = {
17478 (char *) "self", NULL
17479 };
17480
17481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17483 if (SWIG_arg_fail(1)) SWIG_fail;
17484 {
17485 PyThreadState* __tstate = wxPyBeginAllowThreads();
17486 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17487
17488 wxPyEndAllowThreads(__tstate);
17489 if (PyErr_Occurred()) SWIG_fail;
17490 }
17491 {
17492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17493 }
17494 return resultobj;
17495 fail:
17496 return NULL;
17497 }
17498
17499
17500 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17501 PyObject *resultobj = NULL;
17502 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17503 bool result;
17504 PyObject * obj0 = 0 ;
17505 char *kwnames[] = {
17506 (char *) "self", NULL
17507 };
17508
17509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17511 if (SWIG_arg_fail(1)) SWIG_fail;
17512 {
17513 PyThreadState* __tstate = wxPyBeginAllowThreads();
17514 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17515
17516 wxPyEndAllowThreads(__tstate);
17517 if (PyErr_Occurred()) SWIG_fail;
17518 }
17519 {
17520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17521 }
17522 return resultobj;
17523 fail:
17524 return NULL;
17525 }
17526
17527
17528 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17529 PyObject *resultobj = NULL;
17530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17531 bool result;
17532 PyObject * obj0 = 0 ;
17533 char *kwnames[] = {
17534 (char *) "self", NULL
17535 };
17536
17537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17539 if (SWIG_arg_fail(1)) SWIG_fail;
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17543
17544 wxPyEndAllowThreads(__tstate);
17545 if (PyErr_Occurred()) SWIG_fail;
17546 }
17547 {
17548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17549 }
17550 return resultobj;
17551 fail:
17552 return NULL;
17553 }
17554
17555
17556 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj = NULL;
17558 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17559 bool result;
17560 PyObject * obj0 = 0 ;
17561 char *kwnames[] = {
17562 (char *) "self", NULL
17563 };
17564
17565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17567 if (SWIG_arg_fail(1)) SWIG_fail;
17568 {
17569 PyThreadState* __tstate = wxPyBeginAllowThreads();
17570 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17571
17572 wxPyEndAllowThreads(__tstate);
17573 if (PyErr_Occurred()) SWIG_fail;
17574 }
17575 {
17576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17577 }
17578 return resultobj;
17579 fail:
17580 return NULL;
17581 }
17582
17583
17584 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17585 PyObject *resultobj = NULL;
17586 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17587 bool result;
17588 PyObject * obj0 = 0 ;
17589 char *kwnames[] = {
17590 (char *) "self", NULL
17591 };
17592
17593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17595 if (SWIG_arg_fail(1)) SWIG_fail;
17596 {
17597 PyThreadState* __tstate = wxPyBeginAllowThreads();
17598 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17599
17600 wxPyEndAllowThreads(__tstate);
17601 if (PyErr_Occurred()) SWIG_fail;
17602 }
17603 {
17604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17605 }
17606 return resultobj;
17607 fail:
17608 return NULL;
17609 }
17610
17611
17612 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17613 PyObject *resultobj = NULL;
17614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17615 bool result;
17616 PyObject * obj0 = 0 ;
17617 char *kwnames[] = {
17618 (char *) "self", NULL
17619 };
17620
17621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17623 if (SWIG_arg_fail(1)) SWIG_fail;
17624 {
17625 PyThreadState* __tstate = wxPyBeginAllowThreads();
17626 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17627
17628 wxPyEndAllowThreads(__tstate);
17629 if (PyErr_Occurred()) SWIG_fail;
17630 }
17631 {
17632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17633 }
17634 return resultobj;
17635 fail:
17636 return NULL;
17637 }
17638
17639
17640 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17641 PyObject *resultobj = NULL;
17642 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17643 bool result;
17644 PyObject * obj0 = 0 ;
17645 char *kwnames[] = {
17646 (char *) "self", NULL
17647 };
17648
17649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17651 if (SWIG_arg_fail(1)) SWIG_fail;
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17655
17656 wxPyEndAllowThreads(__tstate);
17657 if (PyErr_Occurred()) SWIG_fail;
17658 }
17659 {
17660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17661 }
17662 return resultobj;
17663 fail:
17664 return NULL;
17665 }
17666
17667
17668 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17669 PyObject *resultobj = NULL;
17670 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17671 bool result;
17672 PyObject * obj0 = 0 ;
17673 char *kwnames[] = {
17674 (char *) "self", NULL
17675 };
17676
17677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17679 if (SWIG_arg_fail(1)) SWIG_fail;
17680 {
17681 PyThreadState* __tstate = wxPyBeginAllowThreads();
17682 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17683
17684 wxPyEndAllowThreads(__tstate);
17685 if (PyErr_Occurred()) SWIG_fail;
17686 }
17687 {
17688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17689 }
17690 return resultobj;
17691 fail:
17692 return NULL;
17693 }
17694
17695
17696 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17697 PyObject *resultobj = NULL;
17698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17699 bool result;
17700 PyObject * obj0 = 0 ;
17701 char *kwnames[] = {
17702 (char *) "self", NULL
17703 };
17704
17705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17707 if (SWIG_arg_fail(1)) SWIG_fail;
17708 {
17709 PyThreadState* __tstate = wxPyBeginAllowThreads();
17710 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17711
17712 wxPyEndAllowThreads(__tstate);
17713 if (PyErr_Occurred()) SWIG_fail;
17714 }
17715 {
17716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17717 }
17718 return resultobj;
17719 fail:
17720 return NULL;
17721 }
17722
17723
17724 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17725 PyObject *resultobj = NULL;
17726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17727 bool result;
17728 PyObject * obj0 = 0 ;
17729 char *kwnames[] = {
17730 (char *) "self", NULL
17731 };
17732
17733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17735 if (SWIG_arg_fail(1)) SWIG_fail;
17736 {
17737 PyThreadState* __tstate = wxPyBeginAllowThreads();
17738 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17739
17740 wxPyEndAllowThreads(__tstate);
17741 if (PyErr_Occurred()) SWIG_fail;
17742 }
17743 {
17744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17745 }
17746 return resultobj;
17747 fail:
17748 return NULL;
17749 }
17750
17751
17752 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17753 PyObject *resultobj = NULL;
17754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17755 bool result;
17756 PyObject * obj0 = 0 ;
17757 char *kwnames[] = {
17758 (char *) "self", NULL
17759 };
17760
17761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17763 if (SWIG_arg_fail(1)) SWIG_fail;
17764 {
17765 PyThreadState* __tstate = wxPyBeginAllowThreads();
17766 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17767
17768 wxPyEndAllowThreads(__tstate);
17769 if (PyErr_Occurred()) SWIG_fail;
17770 }
17771 {
17772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17773 }
17774 return resultobj;
17775 fail:
17776 return NULL;
17777 }
17778
17779
17780 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17781 PyObject *resultobj = NULL;
17782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17783 bool result;
17784 PyObject * obj0 = 0 ;
17785 char *kwnames[] = {
17786 (char *) "self", NULL
17787 };
17788
17789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17791 if (SWIG_arg_fail(1)) SWIG_fail;
17792 {
17793 PyThreadState* __tstate = wxPyBeginAllowThreads();
17794 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17795
17796 wxPyEndAllowThreads(__tstate);
17797 if (PyErr_Occurred()) SWIG_fail;
17798 }
17799 {
17800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17801 }
17802 return resultobj;
17803 fail:
17804 return NULL;
17805 }
17806
17807
17808 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17809 PyObject *resultobj = NULL;
17810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17811 bool result;
17812 PyObject * obj0 = 0 ;
17813 char *kwnames[] = {
17814 (char *) "self", NULL
17815 };
17816
17817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17819 if (SWIG_arg_fail(1)) SWIG_fail;
17820 {
17821 PyThreadState* __tstate = wxPyBeginAllowThreads();
17822 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17823
17824 wxPyEndAllowThreads(__tstate);
17825 if (PyErr_Occurred()) SWIG_fail;
17826 }
17827 {
17828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17829 }
17830 return resultobj;
17831 fail:
17832 return NULL;
17833 }
17834
17835
17836 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17837 PyObject *resultobj = NULL;
17838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17839 bool result;
17840 PyObject * obj0 = 0 ;
17841 char *kwnames[] = {
17842 (char *) "self", NULL
17843 };
17844
17845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17847 if (SWIG_arg_fail(1)) SWIG_fail;
17848 {
17849 PyThreadState* __tstate = wxPyBeginAllowThreads();
17850 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17851
17852 wxPyEndAllowThreads(__tstate);
17853 if (PyErr_Occurred()) SWIG_fail;
17854 }
17855 {
17856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17857 }
17858 return resultobj;
17859 fail:
17860 return NULL;
17861 }
17862
17863
17864 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17865 PyObject *resultobj = NULL;
17866 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17867 bool result;
17868 PyObject * obj0 = 0 ;
17869 char *kwnames[] = {
17870 (char *) "self", NULL
17871 };
17872
17873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17875 if (SWIG_arg_fail(1)) SWIG_fail;
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 result = (bool)(arg1)->LeftIsDown();
17879
17880 wxPyEndAllowThreads(__tstate);
17881 if (PyErr_Occurred()) SWIG_fail;
17882 }
17883 {
17884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17885 }
17886 return resultobj;
17887 fail:
17888 return NULL;
17889 }
17890
17891
17892 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17893 PyObject *resultobj = NULL;
17894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17895 bool result;
17896 PyObject * obj0 = 0 ;
17897 char *kwnames[] = {
17898 (char *) "self", NULL
17899 };
17900
17901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17903 if (SWIG_arg_fail(1)) SWIG_fail;
17904 {
17905 PyThreadState* __tstate = wxPyBeginAllowThreads();
17906 result = (bool)(arg1)->MiddleIsDown();
17907
17908 wxPyEndAllowThreads(__tstate);
17909 if (PyErr_Occurred()) SWIG_fail;
17910 }
17911 {
17912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17913 }
17914 return resultobj;
17915 fail:
17916 return NULL;
17917 }
17918
17919
17920 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17921 PyObject *resultobj = NULL;
17922 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17923 bool result;
17924 PyObject * obj0 = 0 ;
17925 char *kwnames[] = {
17926 (char *) "self", NULL
17927 };
17928
17929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17931 if (SWIG_arg_fail(1)) SWIG_fail;
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = (bool)(arg1)->RightIsDown();
17935
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17941 }
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17949 PyObject *resultobj = NULL;
17950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17951 bool result;
17952 PyObject * obj0 = 0 ;
17953 char *kwnames[] = {
17954 (char *) "self", NULL
17955 };
17956
17957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17959 if (SWIG_arg_fail(1)) SWIG_fail;
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17963
17964 wxPyEndAllowThreads(__tstate);
17965 if (PyErr_Occurred()) SWIG_fail;
17966 }
17967 {
17968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17969 }
17970 return resultobj;
17971 fail:
17972 return NULL;
17973 }
17974
17975
17976 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17977 PyObject *resultobj = NULL;
17978 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17979 bool result;
17980 PyObject * obj0 = 0 ;
17981 char *kwnames[] = {
17982 (char *) "self", NULL
17983 };
17984
17985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17987 if (SWIG_arg_fail(1)) SWIG_fail;
17988 {
17989 PyThreadState* __tstate = wxPyBeginAllowThreads();
17990 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17991
17992 wxPyEndAllowThreads(__tstate);
17993 if (PyErr_Occurred()) SWIG_fail;
17994 }
17995 {
17996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17997 }
17998 return resultobj;
17999 fail:
18000 return NULL;
18001 }
18002
18003
18004 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
18005 PyObject *resultobj = NULL;
18006 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18007 bool result;
18008 PyObject * obj0 = 0 ;
18009 char *kwnames[] = {
18010 (char *) "self", NULL
18011 };
18012
18013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
18014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18015 if (SWIG_arg_fail(1)) SWIG_fail;
18016 {
18017 PyThreadState* __tstate = wxPyBeginAllowThreads();
18018 result = (bool)((wxMouseEvent const *)arg1)->Entering();
18019
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18025 }
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj = NULL;
18034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18035 bool result;
18036 PyObject * obj0 = 0 ;
18037 char *kwnames[] = {
18038 (char *) "self", NULL
18039 };
18040
18041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
18042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18043 if (SWIG_arg_fail(1)) SWIG_fail;
18044 {
18045 PyThreadState* __tstate = wxPyBeginAllowThreads();
18046 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
18047
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 {
18052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18053 }
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18061 PyObject *resultobj = NULL;
18062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18063 wxPoint result;
18064 PyObject * obj0 = 0 ;
18065 char *kwnames[] = {
18066 (char *) "self", NULL
18067 };
18068
18069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18071 if (SWIG_arg_fail(1)) SWIG_fail;
18072 {
18073 PyThreadState* __tstate = wxPyBeginAllowThreads();
18074 result = (arg1)->GetPosition();
18075
18076 wxPyEndAllowThreads(__tstate);
18077 if (PyErr_Occurred()) SWIG_fail;
18078 }
18079 {
18080 wxPoint * resultptr;
18081 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18083 }
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj = NULL;
18092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18093 long *arg2 = (long *) 0 ;
18094 long *arg3 = (long *) 0 ;
18095 long temp2 ;
18096 int res2 = 0 ;
18097 long temp3 ;
18098 int res3 = 0 ;
18099 PyObject * obj0 = 0 ;
18100 char *kwnames[] = {
18101 (char *) "self", NULL
18102 };
18103
18104 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18105 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18108 if (SWIG_arg_fail(1)) SWIG_fail;
18109 {
18110 PyThreadState* __tstate = wxPyBeginAllowThreads();
18111 (arg1)->GetPosition(arg2,arg3);
18112
18113 wxPyEndAllowThreads(__tstate);
18114 if (PyErr_Occurred()) SWIG_fail;
18115 }
18116 Py_INCREF(Py_None); resultobj = Py_None;
18117 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18118 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18119 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18120 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18121 return resultobj;
18122 fail:
18123 return NULL;
18124 }
18125
18126
18127 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18128 PyObject *resultobj = NULL;
18129 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18130 wxDC *arg2 = 0 ;
18131 wxPoint result;
18132 PyObject * obj0 = 0 ;
18133 PyObject * obj1 = 0 ;
18134 char *kwnames[] = {
18135 (char *) "self",(char *) "dc", NULL
18136 };
18137
18138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
18139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18140 if (SWIG_arg_fail(1)) SWIG_fail;
18141 {
18142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18143 if (SWIG_arg_fail(2)) SWIG_fail;
18144 if (arg2 == NULL) {
18145 SWIG_null_ref("wxDC");
18146 }
18147 if (SWIG_arg_fail(2)) SWIG_fail;
18148 }
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18152
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 {
18157 wxPoint * resultptr;
18158 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18160 }
18161 return resultobj;
18162 fail:
18163 return NULL;
18164 }
18165
18166
18167 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18168 PyObject *resultobj = NULL;
18169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18170 int result;
18171 PyObject * obj0 = 0 ;
18172 char *kwnames[] = {
18173 (char *) "self", NULL
18174 };
18175
18176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18178 if (SWIG_arg_fail(1)) SWIG_fail;
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 result = (int)((wxMouseEvent const *)arg1)->GetX();
18182
18183 wxPyEndAllowThreads(__tstate);
18184 if (PyErr_Occurred()) SWIG_fail;
18185 }
18186 {
18187 resultobj = SWIG_From_int(static_cast<int >(result));
18188 }
18189 return resultobj;
18190 fail:
18191 return NULL;
18192 }
18193
18194
18195 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18196 PyObject *resultobj = NULL;
18197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18198 int result;
18199 PyObject * obj0 = 0 ;
18200 char *kwnames[] = {
18201 (char *) "self", NULL
18202 };
18203
18204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18206 if (SWIG_arg_fail(1)) SWIG_fail;
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 result = (int)((wxMouseEvent const *)arg1)->GetY();
18210
18211 wxPyEndAllowThreads(__tstate);
18212 if (PyErr_Occurred()) SWIG_fail;
18213 }
18214 {
18215 resultobj = SWIG_From_int(static_cast<int >(result));
18216 }
18217 return resultobj;
18218 fail:
18219 return NULL;
18220 }
18221
18222
18223 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18224 PyObject *resultobj = NULL;
18225 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18226 int result;
18227 PyObject * obj0 = 0 ;
18228 char *kwnames[] = {
18229 (char *) "self", NULL
18230 };
18231
18232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18234 if (SWIG_arg_fail(1)) SWIG_fail;
18235 {
18236 PyThreadState* __tstate = wxPyBeginAllowThreads();
18237 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18238
18239 wxPyEndAllowThreads(__tstate);
18240 if (PyErr_Occurred()) SWIG_fail;
18241 }
18242 {
18243 resultobj = SWIG_From_int(static_cast<int >(result));
18244 }
18245 return resultobj;
18246 fail:
18247 return NULL;
18248 }
18249
18250
18251 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18252 PyObject *resultobj = NULL;
18253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18254 int result;
18255 PyObject * obj0 = 0 ;
18256 char *kwnames[] = {
18257 (char *) "self", NULL
18258 };
18259
18260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18262 if (SWIG_arg_fail(1)) SWIG_fail;
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18266
18267 wxPyEndAllowThreads(__tstate);
18268 if (PyErr_Occurred()) SWIG_fail;
18269 }
18270 {
18271 resultobj = SWIG_From_int(static_cast<int >(result));
18272 }
18273 return resultobj;
18274 fail:
18275 return NULL;
18276 }
18277
18278
18279 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18280 PyObject *resultobj = NULL;
18281 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18282 int result;
18283 PyObject * obj0 = 0 ;
18284 char *kwnames[] = {
18285 (char *) "self", NULL
18286 };
18287
18288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18290 if (SWIG_arg_fail(1)) SWIG_fail;
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18294
18295 wxPyEndAllowThreads(__tstate);
18296 if (PyErr_Occurred()) SWIG_fail;
18297 }
18298 {
18299 resultobj = SWIG_From_int(static_cast<int >(result));
18300 }
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18308 PyObject *resultobj = NULL;
18309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18310 bool result;
18311 PyObject * obj0 = 0 ;
18312 char *kwnames[] = {
18313 (char *) "self", NULL
18314 };
18315
18316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18318 if (SWIG_arg_fail(1)) SWIG_fail;
18319 {
18320 PyThreadState* __tstate = wxPyBeginAllowThreads();
18321 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18322
18323 wxPyEndAllowThreads(__tstate);
18324 if (PyErr_Occurred()) SWIG_fail;
18325 }
18326 {
18327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18328 }
18329 return resultobj;
18330 fail:
18331 return NULL;
18332 }
18333
18334
18335 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18336 PyObject *resultobj = NULL;
18337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18338 int arg2 ;
18339 PyObject * obj0 = 0 ;
18340 PyObject * obj1 = 0 ;
18341 char *kwnames[] = {
18342 (char *) "self",(char *) "m_x", NULL
18343 };
18344
18345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18347 if (SWIG_arg_fail(1)) SWIG_fail;
18348 {
18349 arg2 = static_cast<int >(SWIG_As_int(obj1));
18350 if (SWIG_arg_fail(2)) SWIG_fail;
18351 }
18352 if (arg1) (arg1)->m_x = arg2;
18353
18354 Py_INCREF(Py_None); resultobj = Py_None;
18355 return resultobj;
18356 fail:
18357 return NULL;
18358 }
18359
18360
18361 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18362 PyObject *resultobj = NULL;
18363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18364 int result;
18365 PyObject * obj0 = 0 ;
18366 char *kwnames[] = {
18367 (char *) "self", NULL
18368 };
18369
18370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18372 if (SWIG_arg_fail(1)) SWIG_fail;
18373 result = (int) ((arg1)->m_x);
18374
18375 {
18376 resultobj = SWIG_From_int(static_cast<int >(result));
18377 }
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj = NULL;
18386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18387 int arg2 ;
18388 PyObject * obj0 = 0 ;
18389 PyObject * obj1 = 0 ;
18390 char *kwnames[] = {
18391 (char *) "self",(char *) "m_y", NULL
18392 };
18393
18394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18396 if (SWIG_arg_fail(1)) SWIG_fail;
18397 {
18398 arg2 = static_cast<int >(SWIG_As_int(obj1));
18399 if (SWIG_arg_fail(2)) SWIG_fail;
18400 }
18401 if (arg1) (arg1)->m_y = arg2;
18402
18403 Py_INCREF(Py_None); resultobj = Py_None;
18404 return resultobj;
18405 fail:
18406 return NULL;
18407 }
18408
18409
18410 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18411 PyObject *resultobj = NULL;
18412 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18413 int result;
18414 PyObject * obj0 = 0 ;
18415 char *kwnames[] = {
18416 (char *) "self", NULL
18417 };
18418
18419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18421 if (SWIG_arg_fail(1)) SWIG_fail;
18422 result = (int) ((arg1)->m_y);
18423
18424 {
18425 resultobj = SWIG_From_int(static_cast<int >(result));
18426 }
18427 return resultobj;
18428 fail:
18429 return NULL;
18430 }
18431
18432
18433 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18434 PyObject *resultobj = NULL;
18435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18436 bool arg2 ;
18437 PyObject * obj0 = 0 ;
18438 PyObject * obj1 = 0 ;
18439 char *kwnames[] = {
18440 (char *) "self",(char *) "m_leftDown", NULL
18441 };
18442
18443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18445 if (SWIG_arg_fail(1)) SWIG_fail;
18446 {
18447 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18448 if (SWIG_arg_fail(2)) SWIG_fail;
18449 }
18450 if (arg1) (arg1)->m_leftDown = arg2;
18451
18452 Py_INCREF(Py_None); resultobj = Py_None;
18453 return resultobj;
18454 fail:
18455 return NULL;
18456 }
18457
18458
18459 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18460 PyObject *resultobj = NULL;
18461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18462 bool result;
18463 PyObject * obj0 = 0 ;
18464 char *kwnames[] = {
18465 (char *) "self", NULL
18466 };
18467
18468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18470 if (SWIG_arg_fail(1)) SWIG_fail;
18471 result = (bool) ((arg1)->m_leftDown);
18472
18473 {
18474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18475 }
18476 return resultobj;
18477 fail:
18478 return NULL;
18479 }
18480
18481
18482 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18483 PyObject *resultobj = NULL;
18484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18485 bool arg2 ;
18486 PyObject * obj0 = 0 ;
18487 PyObject * obj1 = 0 ;
18488 char *kwnames[] = {
18489 (char *) "self",(char *) "m_middleDown", NULL
18490 };
18491
18492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18494 if (SWIG_arg_fail(1)) SWIG_fail;
18495 {
18496 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18497 if (SWIG_arg_fail(2)) SWIG_fail;
18498 }
18499 if (arg1) (arg1)->m_middleDown = arg2;
18500
18501 Py_INCREF(Py_None); resultobj = Py_None;
18502 return resultobj;
18503 fail:
18504 return NULL;
18505 }
18506
18507
18508 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18509 PyObject *resultobj = NULL;
18510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18511 bool result;
18512 PyObject * obj0 = 0 ;
18513 char *kwnames[] = {
18514 (char *) "self", NULL
18515 };
18516
18517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18519 if (SWIG_arg_fail(1)) SWIG_fail;
18520 result = (bool) ((arg1)->m_middleDown);
18521
18522 {
18523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18524 }
18525 return resultobj;
18526 fail:
18527 return NULL;
18528 }
18529
18530
18531 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18532 PyObject *resultobj = NULL;
18533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18534 bool arg2 ;
18535 PyObject * obj0 = 0 ;
18536 PyObject * obj1 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self",(char *) "m_rightDown", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 {
18545 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18546 if (SWIG_arg_fail(2)) SWIG_fail;
18547 }
18548 if (arg1) (arg1)->m_rightDown = arg2;
18549
18550 Py_INCREF(Py_None); resultobj = Py_None;
18551 return resultobj;
18552 fail:
18553 return NULL;
18554 }
18555
18556
18557 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj = NULL;
18559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18560 bool result;
18561 PyObject * obj0 = 0 ;
18562 char *kwnames[] = {
18563 (char *) "self", NULL
18564 };
18565
18566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18568 if (SWIG_arg_fail(1)) SWIG_fail;
18569 result = (bool) ((arg1)->m_rightDown);
18570
18571 {
18572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18573 }
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18581 PyObject *resultobj = NULL;
18582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18583 bool arg2 ;
18584 PyObject * obj0 = 0 ;
18585 PyObject * obj1 = 0 ;
18586 char *kwnames[] = {
18587 (char *) "self",(char *) "m_controlDown", NULL
18588 };
18589
18590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18592 if (SWIG_arg_fail(1)) SWIG_fail;
18593 {
18594 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18595 if (SWIG_arg_fail(2)) SWIG_fail;
18596 }
18597 if (arg1) (arg1)->m_controlDown = arg2;
18598
18599 Py_INCREF(Py_None); resultobj = Py_None;
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18607 PyObject *resultobj = NULL;
18608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18609 bool result;
18610 PyObject * obj0 = 0 ;
18611 char *kwnames[] = {
18612 (char *) "self", NULL
18613 };
18614
18615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18617 if (SWIG_arg_fail(1)) SWIG_fail;
18618 result = (bool) ((arg1)->m_controlDown);
18619
18620 {
18621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18622 }
18623 return resultobj;
18624 fail:
18625 return NULL;
18626 }
18627
18628
18629 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18630 PyObject *resultobj = NULL;
18631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18632 bool arg2 ;
18633 PyObject * obj0 = 0 ;
18634 PyObject * obj1 = 0 ;
18635 char *kwnames[] = {
18636 (char *) "self",(char *) "m_shiftDown", NULL
18637 };
18638
18639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18641 if (SWIG_arg_fail(1)) SWIG_fail;
18642 {
18643 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18644 if (SWIG_arg_fail(2)) SWIG_fail;
18645 }
18646 if (arg1) (arg1)->m_shiftDown = arg2;
18647
18648 Py_INCREF(Py_None); resultobj = Py_None;
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18656 PyObject *resultobj = NULL;
18657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18658 bool result;
18659 PyObject * obj0 = 0 ;
18660 char *kwnames[] = {
18661 (char *) "self", NULL
18662 };
18663
18664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18666 if (SWIG_arg_fail(1)) SWIG_fail;
18667 result = (bool) ((arg1)->m_shiftDown);
18668
18669 {
18670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18671 }
18672 return resultobj;
18673 fail:
18674 return NULL;
18675 }
18676
18677
18678 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18679 PyObject *resultobj = NULL;
18680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18681 bool arg2 ;
18682 PyObject * obj0 = 0 ;
18683 PyObject * obj1 = 0 ;
18684 char *kwnames[] = {
18685 (char *) "self",(char *) "m_altDown", NULL
18686 };
18687
18688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18690 if (SWIG_arg_fail(1)) SWIG_fail;
18691 {
18692 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18693 if (SWIG_arg_fail(2)) SWIG_fail;
18694 }
18695 if (arg1) (arg1)->m_altDown = arg2;
18696
18697 Py_INCREF(Py_None); resultobj = Py_None;
18698 return resultobj;
18699 fail:
18700 return NULL;
18701 }
18702
18703
18704 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18705 PyObject *resultobj = NULL;
18706 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18707 bool result;
18708 PyObject * obj0 = 0 ;
18709 char *kwnames[] = {
18710 (char *) "self", NULL
18711 };
18712
18713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18715 if (SWIG_arg_fail(1)) SWIG_fail;
18716 result = (bool) ((arg1)->m_altDown);
18717
18718 {
18719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18720 }
18721 return resultobj;
18722 fail:
18723 return NULL;
18724 }
18725
18726
18727 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18728 PyObject *resultobj = NULL;
18729 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18730 bool arg2 ;
18731 PyObject * obj0 = 0 ;
18732 PyObject * obj1 = 0 ;
18733 char *kwnames[] = {
18734 (char *) "self",(char *) "m_metaDown", NULL
18735 };
18736
18737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18739 if (SWIG_arg_fail(1)) SWIG_fail;
18740 {
18741 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18742 if (SWIG_arg_fail(2)) SWIG_fail;
18743 }
18744 if (arg1) (arg1)->m_metaDown = arg2;
18745
18746 Py_INCREF(Py_None); resultobj = Py_None;
18747 return resultobj;
18748 fail:
18749 return NULL;
18750 }
18751
18752
18753 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18754 PyObject *resultobj = NULL;
18755 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18756 bool result;
18757 PyObject * obj0 = 0 ;
18758 char *kwnames[] = {
18759 (char *) "self", NULL
18760 };
18761
18762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18764 if (SWIG_arg_fail(1)) SWIG_fail;
18765 result = (bool) ((arg1)->m_metaDown);
18766
18767 {
18768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18769 }
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18777 PyObject *resultobj = NULL;
18778 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18779 int arg2 ;
18780 PyObject * obj0 = 0 ;
18781 PyObject * obj1 = 0 ;
18782 char *kwnames[] = {
18783 (char *) "self",(char *) "m_wheelRotation", NULL
18784 };
18785
18786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18788 if (SWIG_arg_fail(1)) SWIG_fail;
18789 {
18790 arg2 = static_cast<int >(SWIG_As_int(obj1));
18791 if (SWIG_arg_fail(2)) SWIG_fail;
18792 }
18793 if (arg1) (arg1)->m_wheelRotation = arg2;
18794
18795 Py_INCREF(Py_None); resultobj = Py_None;
18796 return resultobj;
18797 fail:
18798 return NULL;
18799 }
18800
18801
18802 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18803 PyObject *resultobj = NULL;
18804 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18805 int result;
18806 PyObject * obj0 = 0 ;
18807 char *kwnames[] = {
18808 (char *) "self", NULL
18809 };
18810
18811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18813 if (SWIG_arg_fail(1)) SWIG_fail;
18814 result = (int) ((arg1)->m_wheelRotation);
18815
18816 {
18817 resultobj = SWIG_From_int(static_cast<int >(result));
18818 }
18819 return resultobj;
18820 fail:
18821 return NULL;
18822 }
18823
18824
18825 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18826 PyObject *resultobj = NULL;
18827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18828 int arg2 ;
18829 PyObject * obj0 = 0 ;
18830 PyObject * obj1 = 0 ;
18831 char *kwnames[] = {
18832 (char *) "self",(char *) "m_wheelDelta", NULL
18833 };
18834
18835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18837 if (SWIG_arg_fail(1)) SWIG_fail;
18838 {
18839 arg2 = static_cast<int >(SWIG_As_int(obj1));
18840 if (SWIG_arg_fail(2)) SWIG_fail;
18841 }
18842 if (arg1) (arg1)->m_wheelDelta = arg2;
18843
18844 Py_INCREF(Py_None); resultobj = Py_None;
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj = NULL;
18853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18854 int result;
18855 PyObject * obj0 = 0 ;
18856 char *kwnames[] = {
18857 (char *) "self", NULL
18858 };
18859
18860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18862 if (SWIG_arg_fail(1)) SWIG_fail;
18863 result = (int) ((arg1)->m_wheelDelta);
18864
18865 {
18866 resultobj = SWIG_From_int(static_cast<int >(result));
18867 }
18868 return resultobj;
18869 fail:
18870 return NULL;
18871 }
18872
18873
18874 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18875 PyObject *resultobj = NULL;
18876 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18877 int arg2 ;
18878 PyObject * obj0 = 0 ;
18879 PyObject * obj1 = 0 ;
18880 char *kwnames[] = {
18881 (char *) "self",(char *) "m_linesPerAction", NULL
18882 };
18883
18884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18886 if (SWIG_arg_fail(1)) SWIG_fail;
18887 {
18888 arg2 = static_cast<int >(SWIG_As_int(obj1));
18889 if (SWIG_arg_fail(2)) SWIG_fail;
18890 }
18891 if (arg1) (arg1)->m_linesPerAction = arg2;
18892
18893 Py_INCREF(Py_None); resultobj = Py_None;
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18901 PyObject *resultobj = NULL;
18902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18903 int result;
18904 PyObject * obj0 = 0 ;
18905 char *kwnames[] = {
18906 (char *) "self", NULL
18907 };
18908
18909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18911 if (SWIG_arg_fail(1)) SWIG_fail;
18912 result = (int) ((arg1)->m_linesPerAction);
18913
18914 {
18915 resultobj = SWIG_From_int(static_cast<int >(result));
18916 }
18917 return resultobj;
18918 fail:
18919 return NULL;
18920 }
18921
18922
18923 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18924 PyObject *obj;
18925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18926 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18927 Py_INCREF(obj);
18928 return Py_BuildValue((char *)"");
18929 }
18930 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18931 PyObject *resultobj = NULL;
18932 int arg1 = (int) 0 ;
18933 int arg2 = (int) 0 ;
18934 wxSetCursorEvent *result;
18935 PyObject * obj0 = 0 ;
18936 PyObject * obj1 = 0 ;
18937 char *kwnames[] = {
18938 (char *) "x",(char *) "y", NULL
18939 };
18940
18941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18942 if (obj0) {
18943 {
18944 arg1 = static_cast<int >(SWIG_As_int(obj0));
18945 if (SWIG_arg_fail(1)) SWIG_fail;
18946 }
18947 }
18948 if (obj1) {
18949 {
18950 arg2 = static_cast<int >(SWIG_As_int(obj1));
18951 if (SWIG_arg_fail(2)) SWIG_fail;
18952 }
18953 }
18954 {
18955 PyThreadState* __tstate = wxPyBeginAllowThreads();
18956 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18957
18958 wxPyEndAllowThreads(__tstate);
18959 if (PyErr_Occurred()) SWIG_fail;
18960 }
18961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18962 return resultobj;
18963 fail:
18964 return NULL;
18965 }
18966
18967
18968 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18969 PyObject *resultobj = NULL;
18970 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18971 int result;
18972 PyObject * obj0 = 0 ;
18973 char *kwnames[] = {
18974 (char *) "self", NULL
18975 };
18976
18977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18979 if (SWIG_arg_fail(1)) SWIG_fail;
18980 {
18981 PyThreadState* __tstate = wxPyBeginAllowThreads();
18982 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18983
18984 wxPyEndAllowThreads(__tstate);
18985 if (PyErr_Occurred()) SWIG_fail;
18986 }
18987 {
18988 resultobj = SWIG_From_int(static_cast<int >(result));
18989 }
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18997 PyObject *resultobj = NULL;
18998 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18999 int result;
19000 PyObject * obj0 = 0 ;
19001 char *kwnames[] = {
19002 (char *) "self", NULL
19003 };
19004
19005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
19006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19007 if (SWIG_arg_fail(1)) SWIG_fail;
19008 {
19009 PyThreadState* __tstate = wxPyBeginAllowThreads();
19010 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
19011
19012 wxPyEndAllowThreads(__tstate);
19013 if (PyErr_Occurred()) SWIG_fail;
19014 }
19015 {
19016 resultobj = SWIG_From_int(static_cast<int >(result));
19017 }
19018 return resultobj;
19019 fail:
19020 return NULL;
19021 }
19022
19023
19024 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19025 PyObject *resultobj = NULL;
19026 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19027 wxCursor *arg2 = 0 ;
19028 PyObject * obj0 = 0 ;
19029 PyObject * obj1 = 0 ;
19030 char *kwnames[] = {
19031 (char *) "self",(char *) "cursor", NULL
19032 };
19033
19034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
19035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19036 if (SWIG_arg_fail(1)) SWIG_fail;
19037 {
19038 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
19039 if (SWIG_arg_fail(2)) SWIG_fail;
19040 if (arg2 == NULL) {
19041 SWIG_null_ref("wxCursor");
19042 }
19043 if (SWIG_arg_fail(2)) SWIG_fail;
19044 }
19045 {
19046 PyThreadState* __tstate = wxPyBeginAllowThreads();
19047 (arg1)->SetCursor((wxCursor const &)*arg2);
19048
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 Py_INCREF(Py_None); resultobj = Py_None;
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj = NULL;
19061 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19062 wxCursor *result;
19063 PyObject * obj0 = 0 ;
19064 char *kwnames[] = {
19065 (char *) "self", NULL
19066 };
19067
19068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19070 if (SWIG_arg_fail(1)) SWIG_fail;
19071 {
19072 PyThreadState* __tstate = wxPyBeginAllowThreads();
19073 {
19074 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19075 result = (wxCursor *) &_result_ref;
19076 }
19077
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 {
19082 wxCursor* resultptr = new wxCursor(*result);
19083 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19084 }
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj = NULL;
19093 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19094 bool result;
19095 PyObject * obj0 = 0 ;
19096 char *kwnames[] = {
19097 (char *) "self", NULL
19098 };
19099
19100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
19101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19102 if (SWIG_arg_fail(1)) SWIG_fail;
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19106
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 {
19111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19112 }
19113 return resultobj;
19114 fail:
19115 return NULL;
19116 }
19117
19118
19119 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19120 PyObject *obj;
19121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19122 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19123 Py_INCREF(obj);
19124 return Py_BuildValue((char *)"");
19125 }
19126 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19127 PyObject *resultobj = NULL;
19128 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19129 wxKeyEvent *result;
19130 PyObject * obj0 = 0 ;
19131 char *kwnames[] = {
19132 (char *) "eventType", NULL
19133 };
19134
19135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19136 if (obj0) {
19137 {
19138 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19139 if (SWIG_arg_fail(1)) SWIG_fail;
19140 }
19141 }
19142 {
19143 PyThreadState* __tstate = wxPyBeginAllowThreads();
19144 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19145
19146 wxPyEndAllowThreads(__tstate);
19147 if (PyErr_Occurred()) SWIG_fail;
19148 }
19149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19150 return resultobj;
19151 fail:
19152 return NULL;
19153 }
19154
19155
19156 static PyObject *_wrap_KeyEvent_GetModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19157 PyObject *resultobj = NULL;
19158 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19159 int result;
19160 PyObject * obj0 = 0 ;
19161 char *kwnames[] = {
19162 (char *) "self", NULL
19163 };
19164
19165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetModifiers",kwnames,&obj0)) goto fail;
19166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19167 if (SWIG_arg_fail(1)) SWIG_fail;
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
19171
19172 wxPyEndAllowThreads(__tstate);
19173 if (PyErr_Occurred()) SWIG_fail;
19174 }
19175 {
19176 resultobj = SWIG_From_int(static_cast<int >(result));
19177 }
19178 return resultobj;
19179 fail:
19180 return NULL;
19181 }
19182
19183
19184 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19185 PyObject *resultobj = NULL;
19186 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19187 bool result;
19188 PyObject * obj0 = 0 ;
19189 char *kwnames[] = {
19190 (char *) "self", NULL
19191 };
19192
19193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19195 if (SWIG_arg_fail(1)) SWIG_fail;
19196 {
19197 PyThreadState* __tstate = wxPyBeginAllowThreads();
19198 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19199
19200 wxPyEndAllowThreads(__tstate);
19201 if (PyErr_Occurred()) SWIG_fail;
19202 }
19203 {
19204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19205 }
19206 return resultobj;
19207 fail:
19208 return NULL;
19209 }
19210
19211
19212 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19213 PyObject *resultobj = NULL;
19214 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19215 bool result;
19216 PyObject * obj0 = 0 ;
19217 char *kwnames[] = {
19218 (char *) "self", NULL
19219 };
19220
19221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19223 if (SWIG_arg_fail(1)) SWIG_fail;
19224 {
19225 PyThreadState* __tstate = wxPyBeginAllowThreads();
19226 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19227
19228 wxPyEndAllowThreads(__tstate);
19229 if (PyErr_Occurred()) SWIG_fail;
19230 }
19231 {
19232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19233 }
19234 return resultobj;
19235 fail:
19236 return NULL;
19237 }
19238
19239
19240 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19241 PyObject *resultobj = NULL;
19242 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19243 bool result;
19244 PyObject * obj0 = 0 ;
19245 char *kwnames[] = {
19246 (char *) "self", NULL
19247 };
19248
19249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19251 if (SWIG_arg_fail(1)) SWIG_fail;
19252 {
19253 PyThreadState* __tstate = wxPyBeginAllowThreads();
19254 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19255
19256 wxPyEndAllowThreads(__tstate);
19257 if (PyErr_Occurred()) SWIG_fail;
19258 }
19259 {
19260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19261 }
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19269 PyObject *resultobj = NULL;
19270 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19271 bool result;
19272 PyObject * obj0 = 0 ;
19273 char *kwnames[] = {
19274 (char *) "self", NULL
19275 };
19276
19277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19279 if (SWIG_arg_fail(1)) SWIG_fail;
19280 {
19281 PyThreadState* __tstate = wxPyBeginAllowThreads();
19282 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19283
19284 wxPyEndAllowThreads(__tstate);
19285 if (PyErr_Occurred()) SWIG_fail;
19286 }
19287 {
19288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19289 }
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19297 PyObject *resultobj = NULL;
19298 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19299 bool result;
19300 PyObject * obj0 = 0 ;
19301 char *kwnames[] = {
19302 (char *) "self", NULL
19303 };
19304
19305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19307 if (SWIG_arg_fail(1)) SWIG_fail;
19308 {
19309 PyThreadState* __tstate = wxPyBeginAllowThreads();
19310 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19311
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 {
19316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19317 }
19318 return resultobj;
19319 fail:
19320 return NULL;
19321 }
19322
19323
19324 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19325 PyObject *resultobj = NULL;
19326 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19327 bool result;
19328 PyObject * obj0 = 0 ;
19329 char *kwnames[] = {
19330 (char *) "self", NULL
19331 };
19332
19333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19335 if (SWIG_arg_fail(1)) SWIG_fail;
19336 {
19337 PyThreadState* __tstate = wxPyBeginAllowThreads();
19338 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19339
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 {
19344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19345 }
19346 return resultobj;
19347 fail:
19348 return NULL;
19349 }
19350
19351
19352 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19353 PyObject *resultobj = NULL;
19354 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19355 int result;
19356 PyObject * obj0 = 0 ;
19357 char *kwnames[] = {
19358 (char *) "self", NULL
19359 };
19360
19361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19363 if (SWIG_arg_fail(1)) SWIG_fail;
19364 {
19365 PyThreadState* __tstate = wxPyBeginAllowThreads();
19366 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19367
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 {
19372 resultobj = SWIG_From_int(static_cast<int >(result));
19373 }
19374 return resultobj;
19375 fail:
19376 return NULL;
19377 }
19378
19379
19380 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19381 PyObject *resultobj = NULL;
19382 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19383 int result;
19384 PyObject * obj0 = 0 ;
19385 char *kwnames[] = {
19386 (char *) "self", NULL
19387 };
19388
19389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19391 if (SWIG_arg_fail(1)) SWIG_fail;
19392 {
19393 PyThreadState* __tstate = wxPyBeginAllowThreads();
19394 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19395
19396 wxPyEndAllowThreads(__tstate);
19397 if (PyErr_Occurred()) SWIG_fail;
19398 }
19399 {
19400 resultobj = SWIG_From_int(static_cast<int >(result));
19401 }
19402 return resultobj;
19403 fail:
19404 return NULL;
19405 }
19406
19407
19408 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19409 PyObject *resultobj = NULL;
19410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19411 unsigned int result;
19412 PyObject * obj0 = 0 ;
19413 char *kwnames[] = {
19414 (char *) "self", NULL
19415 };
19416
19417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19419 if (SWIG_arg_fail(1)) SWIG_fail;
19420 {
19421 PyThreadState* __tstate = wxPyBeginAllowThreads();
19422 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19423
19424 wxPyEndAllowThreads(__tstate);
19425 if (PyErr_Occurred()) SWIG_fail;
19426 }
19427 {
19428 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19429 }
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj = NULL;
19438 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19439 unsigned int result;
19440 PyObject * obj0 = 0 ;
19441 char *kwnames[] = {
19442 (char *) "self", NULL
19443 };
19444
19445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19447 if (SWIG_arg_fail(1)) SWIG_fail;
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19451
19452 wxPyEndAllowThreads(__tstate);
19453 if (PyErr_Occurred()) SWIG_fail;
19454 }
19455 {
19456 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19457 }
19458 return resultobj;
19459 fail:
19460 return NULL;
19461 }
19462
19463
19464 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19465 PyObject *resultobj = NULL;
19466 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19467 wxPoint result;
19468 PyObject * obj0 = 0 ;
19469 char *kwnames[] = {
19470 (char *) "self", NULL
19471 };
19472
19473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19475 if (SWIG_arg_fail(1)) SWIG_fail;
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 result = (arg1)->GetPosition();
19479
19480 wxPyEndAllowThreads(__tstate);
19481 if (PyErr_Occurred()) SWIG_fail;
19482 }
19483 {
19484 wxPoint * resultptr;
19485 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19486 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19487 }
19488 return resultobj;
19489 fail:
19490 return NULL;
19491 }
19492
19493
19494 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19495 PyObject *resultobj = NULL;
19496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19497 long *arg2 = (long *) 0 ;
19498 long *arg3 = (long *) 0 ;
19499 long temp2 ;
19500 int res2 = 0 ;
19501 long temp3 ;
19502 int res3 = 0 ;
19503 PyObject * obj0 = 0 ;
19504 char *kwnames[] = {
19505 (char *) "self", NULL
19506 };
19507
19508 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19509 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19512 if (SWIG_arg_fail(1)) SWIG_fail;
19513 {
19514 PyThreadState* __tstate = wxPyBeginAllowThreads();
19515 (arg1)->GetPosition(arg2,arg3);
19516
19517 wxPyEndAllowThreads(__tstate);
19518 if (PyErr_Occurred()) SWIG_fail;
19519 }
19520 Py_INCREF(Py_None); resultobj = Py_None;
19521 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19522 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19523 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19524 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19525 return resultobj;
19526 fail:
19527 return NULL;
19528 }
19529
19530
19531 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19532 PyObject *resultobj = NULL;
19533 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19534 int result;
19535 PyObject * obj0 = 0 ;
19536 char *kwnames[] = {
19537 (char *) "self", NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19542 if (SWIG_arg_fail(1)) SWIG_fail;
19543 {
19544 PyThreadState* __tstate = wxPyBeginAllowThreads();
19545 result = (int)((wxKeyEvent const *)arg1)->GetX();
19546
19547 wxPyEndAllowThreads(__tstate);
19548 if (PyErr_Occurred()) SWIG_fail;
19549 }
19550 {
19551 resultobj = SWIG_From_int(static_cast<int >(result));
19552 }
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19560 PyObject *resultobj = NULL;
19561 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19562 int result;
19563 PyObject * obj0 = 0 ;
19564 char *kwnames[] = {
19565 (char *) "self", NULL
19566 };
19567
19568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19570 if (SWIG_arg_fail(1)) SWIG_fail;
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 result = (int)((wxKeyEvent const *)arg1)->GetY();
19574
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 {
19579 resultobj = SWIG_From_int(static_cast<int >(result));
19580 }
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19588 PyObject *resultobj = NULL;
19589 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19590 int arg2 ;
19591 PyObject * obj0 = 0 ;
19592 PyObject * obj1 = 0 ;
19593 char *kwnames[] = {
19594 (char *) "self",(char *) "m_x", NULL
19595 };
19596
19597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19599 if (SWIG_arg_fail(1)) SWIG_fail;
19600 {
19601 arg2 = static_cast<int >(SWIG_As_int(obj1));
19602 if (SWIG_arg_fail(2)) SWIG_fail;
19603 }
19604 if (arg1) (arg1)->m_x = arg2;
19605
19606 Py_INCREF(Py_None); resultobj = Py_None;
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19614 PyObject *resultobj = NULL;
19615 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19616 int result;
19617 PyObject * obj0 = 0 ;
19618 char *kwnames[] = {
19619 (char *) "self", NULL
19620 };
19621
19622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19624 if (SWIG_arg_fail(1)) SWIG_fail;
19625 result = (int) ((arg1)->m_x);
19626
19627 {
19628 resultobj = SWIG_From_int(static_cast<int >(result));
19629 }
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj = NULL;
19638 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19639 int arg2 ;
19640 PyObject * obj0 = 0 ;
19641 PyObject * obj1 = 0 ;
19642 char *kwnames[] = {
19643 (char *) "self",(char *) "m_y", NULL
19644 };
19645
19646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19648 if (SWIG_arg_fail(1)) SWIG_fail;
19649 {
19650 arg2 = static_cast<int >(SWIG_As_int(obj1));
19651 if (SWIG_arg_fail(2)) SWIG_fail;
19652 }
19653 if (arg1) (arg1)->m_y = arg2;
19654
19655 Py_INCREF(Py_None); resultobj = Py_None;
19656 return resultobj;
19657 fail:
19658 return NULL;
19659 }
19660
19661
19662 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19663 PyObject *resultobj = NULL;
19664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19665 int result;
19666 PyObject * obj0 = 0 ;
19667 char *kwnames[] = {
19668 (char *) "self", NULL
19669 };
19670
19671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19673 if (SWIG_arg_fail(1)) SWIG_fail;
19674 result = (int) ((arg1)->m_y);
19675
19676 {
19677 resultobj = SWIG_From_int(static_cast<int >(result));
19678 }
19679 return resultobj;
19680 fail:
19681 return NULL;
19682 }
19683
19684
19685 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19686 PyObject *resultobj = NULL;
19687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19688 long arg2 ;
19689 PyObject * obj0 = 0 ;
19690 PyObject * obj1 = 0 ;
19691 char *kwnames[] = {
19692 (char *) "self",(char *) "m_keyCode", NULL
19693 };
19694
19695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19697 if (SWIG_arg_fail(1)) SWIG_fail;
19698 {
19699 arg2 = static_cast<long >(SWIG_As_long(obj1));
19700 if (SWIG_arg_fail(2)) SWIG_fail;
19701 }
19702 if (arg1) (arg1)->m_keyCode = arg2;
19703
19704 Py_INCREF(Py_None); resultobj = Py_None;
19705 return resultobj;
19706 fail:
19707 return NULL;
19708 }
19709
19710
19711 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19712 PyObject *resultobj = NULL;
19713 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19714 long result;
19715 PyObject * obj0 = 0 ;
19716 char *kwnames[] = {
19717 (char *) "self", NULL
19718 };
19719
19720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19722 if (SWIG_arg_fail(1)) SWIG_fail;
19723 result = (long) ((arg1)->m_keyCode);
19724
19725 {
19726 resultobj = SWIG_From_long(static_cast<long >(result));
19727 }
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19735 PyObject *resultobj = NULL;
19736 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19737 bool arg2 ;
19738 PyObject * obj0 = 0 ;
19739 PyObject * obj1 = 0 ;
19740 char *kwnames[] = {
19741 (char *) "self",(char *) "m_controlDown", NULL
19742 };
19743
19744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19746 if (SWIG_arg_fail(1)) SWIG_fail;
19747 {
19748 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19749 if (SWIG_arg_fail(2)) SWIG_fail;
19750 }
19751 if (arg1) (arg1)->m_controlDown = arg2;
19752
19753 Py_INCREF(Py_None); resultobj = Py_None;
19754 return resultobj;
19755 fail:
19756 return NULL;
19757 }
19758
19759
19760 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19761 PyObject *resultobj = NULL;
19762 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19763 bool result;
19764 PyObject * obj0 = 0 ;
19765 char *kwnames[] = {
19766 (char *) "self", NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19771 if (SWIG_arg_fail(1)) SWIG_fail;
19772 result = (bool) ((arg1)->m_controlDown);
19773
19774 {
19775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19776 }
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj = NULL;
19785 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19786 bool arg2 ;
19787 PyObject * obj0 = 0 ;
19788 PyObject * obj1 = 0 ;
19789 char *kwnames[] = {
19790 (char *) "self",(char *) "m_shiftDown", NULL
19791 };
19792
19793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19795 if (SWIG_arg_fail(1)) SWIG_fail;
19796 {
19797 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19798 if (SWIG_arg_fail(2)) SWIG_fail;
19799 }
19800 if (arg1) (arg1)->m_shiftDown = arg2;
19801
19802 Py_INCREF(Py_None); resultobj = Py_None;
19803 return resultobj;
19804 fail:
19805 return NULL;
19806 }
19807
19808
19809 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19810 PyObject *resultobj = NULL;
19811 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19812 bool result;
19813 PyObject * obj0 = 0 ;
19814 char *kwnames[] = {
19815 (char *) "self", NULL
19816 };
19817
19818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19820 if (SWIG_arg_fail(1)) SWIG_fail;
19821 result = (bool) ((arg1)->m_shiftDown);
19822
19823 {
19824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19825 }
19826 return resultobj;
19827 fail:
19828 return NULL;
19829 }
19830
19831
19832 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19833 PyObject *resultobj = NULL;
19834 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19835 bool arg2 ;
19836 PyObject * obj0 = 0 ;
19837 PyObject * obj1 = 0 ;
19838 char *kwnames[] = {
19839 (char *) "self",(char *) "m_altDown", NULL
19840 };
19841
19842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19844 if (SWIG_arg_fail(1)) SWIG_fail;
19845 {
19846 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19847 if (SWIG_arg_fail(2)) SWIG_fail;
19848 }
19849 if (arg1) (arg1)->m_altDown = arg2;
19850
19851 Py_INCREF(Py_None); resultobj = Py_None;
19852 return resultobj;
19853 fail:
19854 return NULL;
19855 }
19856
19857
19858 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19859 PyObject *resultobj = NULL;
19860 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19861 bool result;
19862 PyObject * obj0 = 0 ;
19863 char *kwnames[] = {
19864 (char *) "self", NULL
19865 };
19866
19867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19869 if (SWIG_arg_fail(1)) SWIG_fail;
19870 result = (bool) ((arg1)->m_altDown);
19871
19872 {
19873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19874 }
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19882 PyObject *resultobj = NULL;
19883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19884 bool arg2 ;
19885 PyObject * obj0 = 0 ;
19886 PyObject * obj1 = 0 ;
19887 char *kwnames[] = {
19888 (char *) "self",(char *) "m_metaDown", NULL
19889 };
19890
19891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19893 if (SWIG_arg_fail(1)) SWIG_fail;
19894 {
19895 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19896 if (SWIG_arg_fail(2)) SWIG_fail;
19897 }
19898 if (arg1) (arg1)->m_metaDown = arg2;
19899
19900 Py_INCREF(Py_None); resultobj = Py_None;
19901 return resultobj;
19902 fail:
19903 return NULL;
19904 }
19905
19906
19907 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19908 PyObject *resultobj = NULL;
19909 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19910 bool result;
19911 PyObject * obj0 = 0 ;
19912 char *kwnames[] = {
19913 (char *) "self", NULL
19914 };
19915
19916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19918 if (SWIG_arg_fail(1)) SWIG_fail;
19919 result = (bool) ((arg1)->m_metaDown);
19920
19921 {
19922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19923 }
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj = NULL;
19932 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19933 bool arg2 ;
19934 PyObject * obj0 = 0 ;
19935 PyObject * obj1 = 0 ;
19936 char *kwnames[] = {
19937 (char *) "self",(char *) "m_scanCode", NULL
19938 };
19939
19940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19942 if (SWIG_arg_fail(1)) SWIG_fail;
19943 {
19944 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19945 if (SWIG_arg_fail(2)) SWIG_fail;
19946 }
19947 if (arg1) (arg1)->m_scanCode = arg2;
19948
19949 Py_INCREF(Py_None); resultobj = Py_None;
19950 return resultobj;
19951 fail:
19952 return NULL;
19953 }
19954
19955
19956 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19957 PyObject *resultobj = NULL;
19958 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19959 bool result;
19960 PyObject * obj0 = 0 ;
19961 char *kwnames[] = {
19962 (char *) "self", NULL
19963 };
19964
19965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19967 if (SWIG_arg_fail(1)) SWIG_fail;
19968 result = (bool) ((arg1)->m_scanCode);
19969
19970 {
19971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19972 }
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj = NULL;
19981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19982 unsigned int arg2 ;
19983 PyObject * obj0 = 0 ;
19984 PyObject * obj1 = 0 ;
19985 char *kwnames[] = {
19986 (char *) "self",(char *) "m_rawCode", NULL
19987 };
19988
19989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19991 if (SWIG_arg_fail(1)) SWIG_fail;
19992 {
19993 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19994 if (SWIG_arg_fail(2)) SWIG_fail;
19995 }
19996 if (arg1) (arg1)->m_rawCode = arg2;
19997
19998 Py_INCREF(Py_None); resultobj = Py_None;
19999 return resultobj;
20000 fail:
20001 return NULL;
20002 }
20003
20004
20005 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
20006 PyObject *resultobj = NULL;
20007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20008 unsigned int result;
20009 PyObject * obj0 = 0 ;
20010 char *kwnames[] = {
20011 (char *) "self", NULL
20012 };
20013
20014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
20015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20016 if (SWIG_arg_fail(1)) SWIG_fail;
20017 result = (unsigned int) ((arg1)->m_rawCode);
20018
20019 {
20020 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20021 }
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj = NULL;
20030 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20031 unsigned int arg2 ;
20032 PyObject * obj0 = 0 ;
20033 PyObject * obj1 = 0 ;
20034 char *kwnames[] = {
20035 (char *) "self",(char *) "m_rawFlags", NULL
20036 };
20037
20038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
20039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20040 if (SWIG_arg_fail(1)) SWIG_fail;
20041 {
20042 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
20043 if (SWIG_arg_fail(2)) SWIG_fail;
20044 }
20045 if (arg1) (arg1)->m_rawFlags = arg2;
20046
20047 Py_INCREF(Py_None); resultobj = Py_None;
20048 return resultobj;
20049 fail:
20050 return NULL;
20051 }
20052
20053
20054 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
20055 PyObject *resultobj = NULL;
20056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
20057 unsigned int result;
20058 PyObject * obj0 = 0 ;
20059 char *kwnames[] = {
20060 (char *) "self", NULL
20061 };
20062
20063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
20064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20065 if (SWIG_arg_fail(1)) SWIG_fail;
20066 result = (unsigned int) ((arg1)->m_rawFlags);
20067
20068 {
20069 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20070 }
20071 return resultobj;
20072 fail:
20073 return NULL;
20074 }
20075
20076
20077 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
20078 PyObject *obj;
20079 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20080 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
20081 Py_INCREF(obj);
20082 return Py_BuildValue((char *)"");
20083 }
20084 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20085 PyObject *resultobj = NULL;
20086 wxSize const &arg1_defvalue = wxDefaultSize ;
20087 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20088 int arg2 = (int) 0 ;
20089 wxSizeEvent *result;
20090 wxSize temp1 ;
20091 PyObject * obj0 = 0 ;
20092 PyObject * obj1 = 0 ;
20093 char *kwnames[] = {
20094 (char *) "sz",(char *) "winid", NULL
20095 };
20096
20097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20098 if (obj0) {
20099 {
20100 arg1 = &temp1;
20101 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20102 }
20103 }
20104 if (obj1) {
20105 {
20106 arg2 = static_cast<int >(SWIG_As_int(obj1));
20107 if (SWIG_arg_fail(2)) SWIG_fail;
20108 }
20109 }
20110 {
20111 PyThreadState* __tstate = wxPyBeginAllowThreads();
20112 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20113
20114 wxPyEndAllowThreads(__tstate);
20115 if (PyErr_Occurred()) SWIG_fail;
20116 }
20117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20118 return resultobj;
20119 fail:
20120 return NULL;
20121 }
20122
20123
20124 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20125 PyObject *resultobj = NULL;
20126 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20127 wxSize result;
20128 PyObject * obj0 = 0 ;
20129 char *kwnames[] = {
20130 (char *) "self", NULL
20131 };
20132
20133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20135 if (SWIG_arg_fail(1)) SWIG_fail;
20136 {
20137 PyThreadState* __tstate = wxPyBeginAllowThreads();
20138 result = ((wxSizeEvent const *)arg1)->GetSize();
20139
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 {
20144 wxSize * resultptr;
20145 resultptr = new wxSize(static_cast<wxSize & >(result));
20146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20147 }
20148 return resultobj;
20149 fail:
20150 return NULL;
20151 }
20152
20153
20154 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20155 PyObject *resultobj = NULL;
20156 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20157 wxRect result;
20158 PyObject * obj0 = 0 ;
20159 char *kwnames[] = {
20160 (char *) "self", NULL
20161 };
20162
20163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20165 if (SWIG_arg_fail(1)) SWIG_fail;
20166 {
20167 PyThreadState* __tstate = wxPyBeginAllowThreads();
20168 result = ((wxSizeEvent const *)arg1)->GetRect();
20169
20170 wxPyEndAllowThreads(__tstate);
20171 if (PyErr_Occurred()) SWIG_fail;
20172 }
20173 {
20174 wxRect * resultptr;
20175 resultptr = new wxRect(static_cast<wxRect & >(result));
20176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20177 }
20178 return resultobj;
20179 fail:
20180 return NULL;
20181 }
20182
20183
20184 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20185 PyObject *resultobj = NULL;
20186 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20187 wxRect arg2 ;
20188 PyObject * obj0 = 0 ;
20189 PyObject * obj1 = 0 ;
20190 char *kwnames[] = {
20191 (char *) "self",(char *) "rect", NULL
20192 };
20193
20194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20196 if (SWIG_arg_fail(1)) SWIG_fail;
20197 {
20198 wxRect * argp;
20199 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20200 if (SWIG_arg_fail(2)) SWIG_fail;
20201 if (argp == NULL) {
20202 SWIG_null_ref("wxRect");
20203 }
20204 if (SWIG_arg_fail(2)) SWIG_fail;
20205 arg2 = *argp;
20206 }
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 (arg1)->SetRect(arg2);
20210
20211 wxPyEndAllowThreads(__tstate);
20212 if (PyErr_Occurred()) SWIG_fail;
20213 }
20214 Py_INCREF(Py_None); resultobj = Py_None;
20215 return resultobj;
20216 fail:
20217 return NULL;
20218 }
20219
20220
20221 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20222 PyObject *resultobj = NULL;
20223 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20224 wxSize arg2 ;
20225 PyObject * obj0 = 0 ;
20226 PyObject * obj1 = 0 ;
20227 char *kwnames[] = {
20228 (char *) "self",(char *) "size", NULL
20229 };
20230
20231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20233 if (SWIG_arg_fail(1)) SWIG_fail;
20234 {
20235 wxSize * argp;
20236 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20237 if (SWIG_arg_fail(2)) SWIG_fail;
20238 if (argp == NULL) {
20239 SWIG_null_ref("wxSize");
20240 }
20241 if (SWIG_arg_fail(2)) SWIG_fail;
20242 arg2 = *argp;
20243 }
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 wxSizeEvent_SetSize(arg1,arg2);
20247
20248 wxPyEndAllowThreads(__tstate);
20249 if (PyErr_Occurred()) SWIG_fail;
20250 }
20251 Py_INCREF(Py_None); resultobj = Py_None;
20252 return resultobj;
20253 fail:
20254 return NULL;
20255 }
20256
20257
20258 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20259 PyObject *resultobj = NULL;
20260 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20261 wxSize *arg2 = (wxSize *) 0 ;
20262 PyObject * obj0 = 0 ;
20263 PyObject * obj1 = 0 ;
20264 char *kwnames[] = {
20265 (char *) "self",(char *) "m_size", NULL
20266 };
20267
20268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20270 if (SWIG_arg_fail(1)) SWIG_fail;
20271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20272 if (SWIG_arg_fail(2)) SWIG_fail;
20273 if (arg1) (arg1)->m_size = *arg2;
20274
20275 Py_INCREF(Py_None); resultobj = Py_None;
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20283 PyObject *resultobj = NULL;
20284 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20285 wxSize *result;
20286 PyObject * obj0 = 0 ;
20287 char *kwnames[] = {
20288 (char *) "self", NULL
20289 };
20290
20291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20293 if (SWIG_arg_fail(1)) SWIG_fail;
20294 result = (wxSize *)& ((arg1)->m_size);
20295
20296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20304 PyObject *resultobj = NULL;
20305 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20306 wxRect *arg2 = (wxRect *) 0 ;
20307 PyObject * obj0 = 0 ;
20308 PyObject * obj1 = 0 ;
20309 char *kwnames[] = {
20310 (char *) "self",(char *) "m_rect", NULL
20311 };
20312
20313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20315 if (SWIG_arg_fail(1)) SWIG_fail;
20316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20317 if (SWIG_arg_fail(2)) SWIG_fail;
20318 if (arg1) (arg1)->m_rect = *arg2;
20319
20320 Py_INCREF(Py_None); resultobj = Py_None;
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20328 PyObject *resultobj = NULL;
20329 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20330 wxRect *result;
20331 PyObject * obj0 = 0 ;
20332 char *kwnames[] = {
20333 (char *) "self", NULL
20334 };
20335
20336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20338 if (SWIG_arg_fail(1)) SWIG_fail;
20339 result = (wxRect *)& ((arg1)->m_rect);
20340
20341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20342 return resultobj;
20343 fail:
20344 return NULL;
20345 }
20346
20347
20348 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20349 PyObject *obj;
20350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20351 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20352 Py_INCREF(obj);
20353 return Py_BuildValue((char *)"");
20354 }
20355 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20356 PyObject *resultobj = NULL;
20357 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20358 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20359 int arg2 = (int) 0 ;
20360 wxMoveEvent *result;
20361 wxPoint temp1 ;
20362 PyObject * obj0 = 0 ;
20363 PyObject * obj1 = 0 ;
20364 char *kwnames[] = {
20365 (char *) "pos",(char *) "winid", NULL
20366 };
20367
20368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20369 if (obj0) {
20370 {
20371 arg1 = &temp1;
20372 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20373 }
20374 }
20375 if (obj1) {
20376 {
20377 arg2 = static_cast<int >(SWIG_As_int(obj1));
20378 if (SWIG_arg_fail(2)) SWIG_fail;
20379 }
20380 }
20381 {
20382 PyThreadState* __tstate = wxPyBeginAllowThreads();
20383 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20384
20385 wxPyEndAllowThreads(__tstate);
20386 if (PyErr_Occurred()) SWIG_fail;
20387 }
20388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20389 return resultobj;
20390 fail:
20391 return NULL;
20392 }
20393
20394
20395 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20396 PyObject *resultobj = NULL;
20397 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20398 wxPoint result;
20399 PyObject * obj0 = 0 ;
20400 char *kwnames[] = {
20401 (char *) "self", NULL
20402 };
20403
20404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20406 if (SWIG_arg_fail(1)) SWIG_fail;
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = ((wxMoveEvent const *)arg1)->GetPosition();
20410
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 {
20415 wxPoint * resultptr;
20416 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20418 }
20419 return resultobj;
20420 fail:
20421 return NULL;
20422 }
20423
20424
20425 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20426 PyObject *resultobj = NULL;
20427 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20428 wxRect result;
20429 PyObject * obj0 = 0 ;
20430 char *kwnames[] = {
20431 (char *) "self", NULL
20432 };
20433
20434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20436 if (SWIG_arg_fail(1)) SWIG_fail;
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = ((wxMoveEvent const *)arg1)->GetRect();
20440
20441 wxPyEndAllowThreads(__tstate);
20442 if (PyErr_Occurred()) SWIG_fail;
20443 }
20444 {
20445 wxRect * resultptr;
20446 resultptr = new wxRect(static_cast<wxRect & >(result));
20447 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20448 }
20449 return resultobj;
20450 fail:
20451 return NULL;
20452 }
20453
20454
20455 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj = NULL;
20457 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20458 wxRect *arg2 = 0 ;
20459 wxRect temp2 ;
20460 PyObject * obj0 = 0 ;
20461 PyObject * obj1 = 0 ;
20462 char *kwnames[] = {
20463 (char *) "self",(char *) "rect", NULL
20464 };
20465
20466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20468 if (SWIG_arg_fail(1)) SWIG_fail;
20469 {
20470 arg2 = &temp2;
20471 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20472 }
20473 {
20474 PyThreadState* __tstate = wxPyBeginAllowThreads();
20475 (arg1)->SetRect((wxRect const &)*arg2);
20476
20477 wxPyEndAllowThreads(__tstate);
20478 if (PyErr_Occurred()) SWIG_fail;
20479 }
20480 Py_INCREF(Py_None); resultobj = Py_None;
20481 return resultobj;
20482 fail:
20483 return NULL;
20484 }
20485
20486
20487 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20488 PyObject *resultobj = NULL;
20489 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20490 wxPoint *arg2 = 0 ;
20491 wxPoint temp2 ;
20492 PyObject * obj0 = 0 ;
20493 PyObject * obj1 = 0 ;
20494 char *kwnames[] = {
20495 (char *) "self",(char *) "pos", NULL
20496 };
20497
20498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20500 if (SWIG_arg_fail(1)) SWIG_fail;
20501 {
20502 arg2 = &temp2;
20503 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20504 }
20505 {
20506 PyThreadState* __tstate = wxPyBeginAllowThreads();
20507 (arg1)->SetPosition((wxPoint const &)*arg2);
20508
20509 wxPyEndAllowThreads(__tstate);
20510 if (PyErr_Occurred()) SWIG_fail;
20511 }
20512 Py_INCREF(Py_None); resultobj = Py_None;
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20520 PyObject *obj;
20521 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20522 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20523 Py_INCREF(obj);
20524 return Py_BuildValue((char *)"");
20525 }
20526 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20527 PyObject *resultobj = NULL;
20528 int arg1 = (int) 0 ;
20529 wxPaintEvent *result;
20530 PyObject * obj0 = 0 ;
20531 char *kwnames[] = {
20532 (char *) "Id", NULL
20533 };
20534
20535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20536 if (obj0) {
20537 {
20538 arg1 = static_cast<int >(SWIG_As_int(obj0));
20539 if (SWIG_arg_fail(1)) SWIG_fail;
20540 }
20541 }
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20545
20546 wxPyEndAllowThreads(__tstate);
20547 if (PyErr_Occurred()) SWIG_fail;
20548 }
20549 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20550 return resultobj;
20551 fail:
20552 return NULL;
20553 }
20554
20555
20556 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20557 PyObject *obj;
20558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20559 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20560 Py_INCREF(obj);
20561 return Py_BuildValue((char *)"");
20562 }
20563 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20564 PyObject *resultobj = NULL;
20565 int arg1 = (int) 0 ;
20566 wxNcPaintEvent *result;
20567 PyObject * obj0 = 0 ;
20568 char *kwnames[] = {
20569 (char *) "winid", NULL
20570 };
20571
20572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20573 if (obj0) {
20574 {
20575 arg1 = static_cast<int >(SWIG_As_int(obj0));
20576 if (SWIG_arg_fail(1)) SWIG_fail;
20577 }
20578 }
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20582
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20594 PyObject *obj;
20595 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20596 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20597 Py_INCREF(obj);
20598 return Py_BuildValue((char *)"");
20599 }
20600 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20601 PyObject *resultobj = NULL;
20602 int arg1 = (int) 0 ;
20603 wxDC *arg2 = (wxDC *) NULL ;
20604 wxEraseEvent *result;
20605 PyObject * obj0 = 0 ;
20606 PyObject * obj1 = 0 ;
20607 char *kwnames[] = {
20608 (char *) "Id",(char *) "dc", NULL
20609 };
20610
20611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20612 if (obj0) {
20613 {
20614 arg1 = static_cast<int >(SWIG_As_int(obj0));
20615 if (SWIG_arg_fail(1)) SWIG_fail;
20616 }
20617 }
20618 if (obj1) {
20619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20620 if (SWIG_arg_fail(2)) SWIG_fail;
20621 }
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20625
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20637 PyObject *resultobj = NULL;
20638 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20639 wxDC *result;
20640 PyObject * obj0 = 0 ;
20641 char *kwnames[] = {
20642 (char *) "self", NULL
20643 };
20644
20645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20647 if (SWIG_arg_fail(1)) SWIG_fail;
20648 {
20649 PyThreadState* __tstate = wxPyBeginAllowThreads();
20650 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20651
20652 wxPyEndAllowThreads(__tstate);
20653 if (PyErr_Occurred()) SWIG_fail;
20654 }
20655 {
20656 resultobj = wxPyMake_wxObject(result, (bool)0);
20657 }
20658 return resultobj;
20659 fail:
20660 return NULL;
20661 }
20662
20663
20664 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20665 PyObject *obj;
20666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20667 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20668 Py_INCREF(obj);
20669 return Py_BuildValue((char *)"");
20670 }
20671 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj = NULL;
20673 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20674 int arg2 = (int) 0 ;
20675 wxFocusEvent *result;
20676 PyObject * obj0 = 0 ;
20677 PyObject * obj1 = 0 ;
20678 char *kwnames[] = {
20679 (char *) "type",(char *) "winid", NULL
20680 };
20681
20682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20683 if (obj0) {
20684 {
20685 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20686 if (SWIG_arg_fail(1)) SWIG_fail;
20687 }
20688 }
20689 if (obj1) {
20690 {
20691 arg2 = static_cast<int >(SWIG_As_int(obj1));
20692 if (SWIG_arg_fail(2)) SWIG_fail;
20693 }
20694 }
20695 {
20696 PyThreadState* __tstate = wxPyBeginAllowThreads();
20697 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20698
20699 wxPyEndAllowThreads(__tstate);
20700 if (PyErr_Occurred()) SWIG_fail;
20701 }
20702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20703 return resultobj;
20704 fail:
20705 return NULL;
20706 }
20707
20708
20709 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20710 PyObject *resultobj = NULL;
20711 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20712 wxWindow *result;
20713 PyObject * obj0 = 0 ;
20714 char *kwnames[] = {
20715 (char *) "self", NULL
20716 };
20717
20718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20720 if (SWIG_arg_fail(1)) SWIG_fail;
20721 {
20722 PyThreadState* __tstate = wxPyBeginAllowThreads();
20723 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20724
20725 wxPyEndAllowThreads(__tstate);
20726 if (PyErr_Occurred()) SWIG_fail;
20727 }
20728 {
20729 resultobj = wxPyMake_wxObject(result, (bool)0);
20730 }
20731 return resultobj;
20732 fail:
20733 return NULL;
20734 }
20735
20736
20737 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20738 PyObject *resultobj = NULL;
20739 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20740 wxWindow *arg2 = (wxWindow *) 0 ;
20741 PyObject * obj0 = 0 ;
20742 PyObject * obj1 = 0 ;
20743 char *kwnames[] = {
20744 (char *) "self",(char *) "win", NULL
20745 };
20746
20747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20749 if (SWIG_arg_fail(1)) SWIG_fail;
20750 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20751 if (SWIG_arg_fail(2)) SWIG_fail;
20752 {
20753 PyThreadState* __tstate = wxPyBeginAllowThreads();
20754 (arg1)->SetWindow(arg2);
20755
20756 wxPyEndAllowThreads(__tstate);
20757 if (PyErr_Occurred()) SWIG_fail;
20758 }
20759 Py_INCREF(Py_None); resultobj = Py_None;
20760 return resultobj;
20761 fail:
20762 return NULL;
20763 }
20764
20765
20766 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20767 PyObject *obj;
20768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20769 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20770 Py_INCREF(obj);
20771 return Py_BuildValue((char *)"");
20772 }
20773 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20774 PyObject *resultobj = NULL;
20775 wxWindow *arg1 = (wxWindow *) NULL ;
20776 wxChildFocusEvent *result;
20777 PyObject * obj0 = 0 ;
20778 char *kwnames[] = {
20779 (char *) "win", NULL
20780 };
20781
20782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20783 if (obj0) {
20784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20785 if (SWIG_arg_fail(1)) SWIG_fail;
20786 }
20787 {
20788 PyThreadState* __tstate = wxPyBeginAllowThreads();
20789 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20790
20791 wxPyEndAllowThreads(__tstate);
20792 if (PyErr_Occurred()) SWIG_fail;
20793 }
20794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20795 return resultobj;
20796 fail:
20797 return NULL;
20798 }
20799
20800
20801 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20802 PyObject *resultobj = NULL;
20803 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20804 wxWindow *result;
20805 PyObject * obj0 = 0 ;
20806 char *kwnames[] = {
20807 (char *) "self", NULL
20808 };
20809
20810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20812 if (SWIG_arg_fail(1)) SWIG_fail;
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20816
20817 wxPyEndAllowThreads(__tstate);
20818 if (PyErr_Occurred()) SWIG_fail;
20819 }
20820 {
20821 resultobj = wxPyMake_wxObject(result, (bool)0);
20822 }
20823 return resultobj;
20824 fail:
20825 return NULL;
20826 }
20827
20828
20829 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20830 PyObject *obj;
20831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20832 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20833 Py_INCREF(obj);
20834 return Py_BuildValue((char *)"");
20835 }
20836 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20837 PyObject *resultobj = NULL;
20838 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20839 bool arg2 = (bool) true ;
20840 int arg3 = (int) 0 ;
20841 wxActivateEvent *result;
20842 PyObject * obj0 = 0 ;
20843 PyObject * obj1 = 0 ;
20844 PyObject * obj2 = 0 ;
20845 char *kwnames[] = {
20846 (char *) "type",(char *) "active",(char *) "Id", NULL
20847 };
20848
20849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20850 if (obj0) {
20851 {
20852 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20853 if (SWIG_arg_fail(1)) SWIG_fail;
20854 }
20855 }
20856 if (obj1) {
20857 {
20858 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20859 if (SWIG_arg_fail(2)) SWIG_fail;
20860 }
20861 }
20862 if (obj2) {
20863 {
20864 arg3 = static_cast<int >(SWIG_As_int(obj2));
20865 if (SWIG_arg_fail(3)) SWIG_fail;
20866 }
20867 }
20868 {
20869 PyThreadState* __tstate = wxPyBeginAllowThreads();
20870 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20871
20872 wxPyEndAllowThreads(__tstate);
20873 if (PyErr_Occurred()) SWIG_fail;
20874 }
20875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20883 PyObject *resultobj = NULL;
20884 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20885 bool result;
20886 PyObject * obj0 = 0 ;
20887 char *kwnames[] = {
20888 (char *) "self", NULL
20889 };
20890
20891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20893 if (SWIG_arg_fail(1)) SWIG_fail;
20894 {
20895 PyThreadState* __tstate = wxPyBeginAllowThreads();
20896 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20897
20898 wxPyEndAllowThreads(__tstate);
20899 if (PyErr_Occurred()) SWIG_fail;
20900 }
20901 {
20902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20903 }
20904 return resultobj;
20905 fail:
20906 return NULL;
20907 }
20908
20909
20910 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20911 PyObject *obj;
20912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20913 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20914 Py_INCREF(obj);
20915 return Py_BuildValue((char *)"");
20916 }
20917 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20918 PyObject *resultobj = NULL;
20919 int arg1 = (int) 0 ;
20920 wxInitDialogEvent *result;
20921 PyObject * obj0 = 0 ;
20922 char *kwnames[] = {
20923 (char *) "Id", NULL
20924 };
20925
20926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20927 if (obj0) {
20928 {
20929 arg1 = static_cast<int >(SWIG_As_int(obj0));
20930 if (SWIG_arg_fail(1)) SWIG_fail;
20931 }
20932 }
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20936
20937 wxPyEndAllowThreads(__tstate);
20938 if (PyErr_Occurred()) SWIG_fail;
20939 }
20940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20941 return resultobj;
20942 fail:
20943 return NULL;
20944 }
20945
20946
20947 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20948 PyObject *obj;
20949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20950 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20951 Py_INCREF(obj);
20952 return Py_BuildValue((char *)"");
20953 }
20954 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20955 PyObject *resultobj = NULL;
20956 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20957 int arg2 = (int) 0 ;
20958 wxMenu *arg3 = (wxMenu *) NULL ;
20959 wxMenuEvent *result;
20960 PyObject * obj0 = 0 ;
20961 PyObject * obj1 = 0 ;
20962 PyObject * obj2 = 0 ;
20963 char *kwnames[] = {
20964 (char *) "type",(char *) "winid",(char *) "menu", NULL
20965 };
20966
20967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20968 if (obj0) {
20969 {
20970 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20971 if (SWIG_arg_fail(1)) SWIG_fail;
20972 }
20973 }
20974 if (obj1) {
20975 {
20976 arg2 = static_cast<int >(SWIG_As_int(obj1));
20977 if (SWIG_arg_fail(2)) SWIG_fail;
20978 }
20979 }
20980 if (obj2) {
20981 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20982 if (SWIG_arg_fail(3)) SWIG_fail;
20983 }
20984 {
20985 PyThreadState* __tstate = wxPyBeginAllowThreads();
20986 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20987
20988 wxPyEndAllowThreads(__tstate);
20989 if (PyErr_Occurred()) SWIG_fail;
20990 }
20991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20992 return resultobj;
20993 fail:
20994 return NULL;
20995 }
20996
20997
20998 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20999 PyObject *resultobj = NULL;
21000 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21001 int result;
21002 PyObject * obj0 = 0 ;
21003 char *kwnames[] = {
21004 (char *) "self", NULL
21005 };
21006
21007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
21008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21009 if (SWIG_arg_fail(1)) SWIG_fail;
21010 {
21011 PyThreadState* __tstate = wxPyBeginAllowThreads();
21012 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
21013
21014 wxPyEndAllowThreads(__tstate);
21015 if (PyErr_Occurred()) SWIG_fail;
21016 }
21017 {
21018 resultobj = SWIG_From_int(static_cast<int >(result));
21019 }
21020 return resultobj;
21021 fail:
21022 return NULL;
21023 }
21024
21025
21026 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
21027 PyObject *resultobj = NULL;
21028 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21029 bool result;
21030 PyObject * obj0 = 0 ;
21031 char *kwnames[] = {
21032 (char *) "self", NULL
21033 };
21034
21035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
21036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21037 if (SWIG_arg_fail(1)) SWIG_fail;
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
21041
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 {
21046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21047 }
21048 return resultobj;
21049 fail:
21050 return NULL;
21051 }
21052
21053
21054 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
21055 PyObject *resultobj = NULL;
21056 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
21057 wxMenu *result;
21058 PyObject * obj0 = 0 ;
21059 char *kwnames[] = {
21060 (char *) "self", NULL
21061 };
21062
21063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
21064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21065 if (SWIG_arg_fail(1)) SWIG_fail;
21066 {
21067 PyThreadState* __tstate = wxPyBeginAllowThreads();
21068 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
21069
21070 wxPyEndAllowThreads(__tstate);
21071 if (PyErr_Occurred()) SWIG_fail;
21072 }
21073 {
21074 resultobj = wxPyMake_wxObject(result, (bool)0);
21075 }
21076 return resultobj;
21077 fail:
21078 return NULL;
21079 }
21080
21081
21082 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
21083 PyObject *obj;
21084 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21085 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21086 Py_INCREF(obj);
21087 return Py_BuildValue((char *)"");
21088 }
21089 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21090 PyObject *resultobj = NULL;
21091 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21092 int arg2 = (int) 0 ;
21093 wxCloseEvent *result;
21094 PyObject * obj0 = 0 ;
21095 PyObject * obj1 = 0 ;
21096 char *kwnames[] = {
21097 (char *) "type",(char *) "winid", NULL
21098 };
21099
21100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21101 if (obj0) {
21102 {
21103 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21104 if (SWIG_arg_fail(1)) SWIG_fail;
21105 }
21106 }
21107 if (obj1) {
21108 {
21109 arg2 = static_cast<int >(SWIG_As_int(obj1));
21110 if (SWIG_arg_fail(2)) SWIG_fail;
21111 }
21112 }
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21116
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21121 return resultobj;
21122 fail:
21123 return NULL;
21124 }
21125
21126
21127 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21128 PyObject *resultobj = NULL;
21129 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21130 bool arg2 ;
21131 PyObject * obj0 = 0 ;
21132 PyObject * obj1 = 0 ;
21133 char *kwnames[] = {
21134 (char *) "self",(char *) "logOff", NULL
21135 };
21136
21137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21139 if (SWIG_arg_fail(1)) SWIG_fail;
21140 {
21141 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21142 if (SWIG_arg_fail(2)) SWIG_fail;
21143 }
21144 {
21145 PyThreadState* __tstate = wxPyBeginAllowThreads();
21146 (arg1)->SetLoggingOff(arg2);
21147
21148 wxPyEndAllowThreads(__tstate);
21149 if (PyErr_Occurred()) SWIG_fail;
21150 }
21151 Py_INCREF(Py_None); resultobj = Py_None;
21152 return resultobj;
21153 fail:
21154 return NULL;
21155 }
21156
21157
21158 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21159 PyObject *resultobj = NULL;
21160 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21161 bool result;
21162 PyObject * obj0 = 0 ;
21163 char *kwnames[] = {
21164 (char *) "self", NULL
21165 };
21166
21167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21169 if (SWIG_arg_fail(1)) SWIG_fail;
21170 {
21171 PyThreadState* __tstate = wxPyBeginAllowThreads();
21172 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21173
21174 wxPyEndAllowThreads(__tstate);
21175 if (PyErr_Occurred()) SWIG_fail;
21176 }
21177 {
21178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21179 }
21180 return resultobj;
21181 fail:
21182 return NULL;
21183 }
21184
21185
21186 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21187 PyObject *resultobj = NULL;
21188 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21189 bool arg2 = (bool) true ;
21190 PyObject * obj0 = 0 ;
21191 PyObject * obj1 = 0 ;
21192 char *kwnames[] = {
21193 (char *) "self",(char *) "veto", NULL
21194 };
21195
21196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21198 if (SWIG_arg_fail(1)) SWIG_fail;
21199 if (obj1) {
21200 {
21201 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21202 if (SWIG_arg_fail(2)) SWIG_fail;
21203 }
21204 }
21205 {
21206 PyThreadState* __tstate = wxPyBeginAllowThreads();
21207 (arg1)->Veto(arg2);
21208
21209 wxPyEndAllowThreads(__tstate);
21210 if (PyErr_Occurred()) SWIG_fail;
21211 }
21212 Py_INCREF(Py_None); resultobj = Py_None;
21213 return resultobj;
21214 fail:
21215 return NULL;
21216 }
21217
21218
21219 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21220 PyObject *resultobj = NULL;
21221 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21222 bool result;
21223 PyObject * obj0 = 0 ;
21224 char *kwnames[] = {
21225 (char *) "self", NULL
21226 };
21227
21228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21230 if (SWIG_arg_fail(1)) SWIG_fail;
21231 {
21232 PyThreadState* __tstate = wxPyBeginAllowThreads();
21233 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21234
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 {
21239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21240 }
21241 return resultobj;
21242 fail:
21243 return NULL;
21244 }
21245
21246
21247 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21248 PyObject *resultobj = NULL;
21249 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21250 bool arg2 ;
21251 PyObject * obj0 = 0 ;
21252 PyObject * obj1 = 0 ;
21253 char *kwnames[] = {
21254 (char *) "self",(char *) "canVeto", NULL
21255 };
21256
21257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21259 if (SWIG_arg_fail(1)) SWIG_fail;
21260 {
21261 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21262 if (SWIG_arg_fail(2)) SWIG_fail;
21263 }
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 (arg1)->SetCanVeto(arg2);
21267
21268 wxPyEndAllowThreads(__tstate);
21269 if (PyErr_Occurred()) SWIG_fail;
21270 }
21271 Py_INCREF(Py_None); resultobj = Py_None;
21272 return resultobj;
21273 fail:
21274 return NULL;
21275 }
21276
21277
21278 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21279 PyObject *resultobj = NULL;
21280 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21281 bool result;
21282 PyObject * obj0 = 0 ;
21283 char *kwnames[] = {
21284 (char *) "self", NULL
21285 };
21286
21287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21289 if (SWIG_arg_fail(1)) SWIG_fail;
21290 {
21291 PyThreadState* __tstate = wxPyBeginAllowThreads();
21292 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21293
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 {
21298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21299 }
21300 return resultobj;
21301 fail:
21302 return NULL;
21303 }
21304
21305
21306 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21307 PyObject *obj;
21308 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21309 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21310 Py_INCREF(obj);
21311 return Py_BuildValue((char *)"");
21312 }
21313 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21314 PyObject *resultobj = NULL;
21315 int arg1 = (int) 0 ;
21316 bool arg2 = (bool) false ;
21317 wxShowEvent *result;
21318 PyObject * obj0 = 0 ;
21319 PyObject * obj1 = 0 ;
21320 char *kwnames[] = {
21321 (char *) "winid",(char *) "show", NULL
21322 };
21323
21324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21325 if (obj0) {
21326 {
21327 arg1 = static_cast<int >(SWIG_As_int(obj0));
21328 if (SWIG_arg_fail(1)) SWIG_fail;
21329 }
21330 }
21331 if (obj1) {
21332 {
21333 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21334 if (SWIG_arg_fail(2)) SWIG_fail;
21335 }
21336 }
21337 {
21338 PyThreadState* __tstate = wxPyBeginAllowThreads();
21339 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21340
21341 wxPyEndAllowThreads(__tstate);
21342 if (PyErr_Occurred()) SWIG_fail;
21343 }
21344 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21345 return resultobj;
21346 fail:
21347 return NULL;
21348 }
21349
21350
21351 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21352 PyObject *resultobj = NULL;
21353 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21354 bool arg2 ;
21355 PyObject * obj0 = 0 ;
21356 PyObject * obj1 = 0 ;
21357 char *kwnames[] = {
21358 (char *) "self",(char *) "show", NULL
21359 };
21360
21361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21363 if (SWIG_arg_fail(1)) SWIG_fail;
21364 {
21365 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21366 if (SWIG_arg_fail(2)) SWIG_fail;
21367 }
21368 {
21369 PyThreadState* __tstate = wxPyBeginAllowThreads();
21370 (arg1)->SetShow(arg2);
21371
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 Py_INCREF(Py_None); resultobj = Py_None;
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj = NULL;
21384 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21385 bool result;
21386 PyObject * obj0 = 0 ;
21387 char *kwnames[] = {
21388 (char *) "self", NULL
21389 };
21390
21391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21393 if (SWIG_arg_fail(1)) SWIG_fail;
21394 {
21395 PyThreadState* __tstate = wxPyBeginAllowThreads();
21396 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21397
21398 wxPyEndAllowThreads(__tstate);
21399 if (PyErr_Occurred()) SWIG_fail;
21400 }
21401 {
21402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21403 }
21404 return resultobj;
21405 fail:
21406 return NULL;
21407 }
21408
21409
21410 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21411 PyObject *obj;
21412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21413 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21414 Py_INCREF(obj);
21415 return Py_BuildValue((char *)"");
21416 }
21417 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21418 PyObject *resultobj = NULL;
21419 int arg1 = (int) 0 ;
21420 bool arg2 = (bool) true ;
21421 wxIconizeEvent *result;
21422 PyObject * obj0 = 0 ;
21423 PyObject * obj1 = 0 ;
21424 char *kwnames[] = {
21425 (char *) "id",(char *) "iconized", NULL
21426 };
21427
21428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21429 if (obj0) {
21430 {
21431 arg1 = static_cast<int >(SWIG_As_int(obj0));
21432 if (SWIG_arg_fail(1)) SWIG_fail;
21433 }
21434 }
21435 if (obj1) {
21436 {
21437 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21438 if (SWIG_arg_fail(2)) SWIG_fail;
21439 }
21440 }
21441 {
21442 PyThreadState* __tstate = wxPyBeginAllowThreads();
21443 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21444
21445 wxPyEndAllowThreads(__tstate);
21446 if (PyErr_Occurred()) SWIG_fail;
21447 }
21448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21449 return resultobj;
21450 fail:
21451 return NULL;
21452 }
21453
21454
21455 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21456 PyObject *resultobj = NULL;
21457 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21458 bool result;
21459 PyObject * obj0 = 0 ;
21460 char *kwnames[] = {
21461 (char *) "self", NULL
21462 };
21463
21464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21466 if (SWIG_arg_fail(1)) SWIG_fail;
21467 {
21468 PyThreadState* __tstate = wxPyBeginAllowThreads();
21469 result = (bool)(arg1)->Iconized();
21470
21471 wxPyEndAllowThreads(__tstate);
21472 if (PyErr_Occurred()) SWIG_fail;
21473 }
21474 {
21475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21476 }
21477 return resultobj;
21478 fail:
21479 return NULL;
21480 }
21481
21482
21483 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21484 PyObject *obj;
21485 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21486 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21487 Py_INCREF(obj);
21488 return Py_BuildValue((char *)"");
21489 }
21490 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21491 PyObject *resultobj = NULL;
21492 int arg1 = (int) 0 ;
21493 wxMaximizeEvent *result;
21494 PyObject * obj0 = 0 ;
21495 char *kwnames[] = {
21496 (char *) "id", NULL
21497 };
21498
21499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21500 if (obj0) {
21501 {
21502 arg1 = static_cast<int >(SWIG_As_int(obj0));
21503 if (SWIG_arg_fail(1)) SWIG_fail;
21504 }
21505 }
21506 {
21507 PyThreadState* __tstate = wxPyBeginAllowThreads();
21508 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21509
21510 wxPyEndAllowThreads(__tstate);
21511 if (PyErr_Occurred()) SWIG_fail;
21512 }
21513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21514 return resultobj;
21515 fail:
21516 return NULL;
21517 }
21518
21519
21520 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21521 PyObject *obj;
21522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21523 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21524 Py_INCREF(obj);
21525 return Py_BuildValue((char *)"");
21526 }
21527 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21528 PyObject *resultobj = NULL;
21529 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21530 wxPoint result;
21531 PyObject * obj0 = 0 ;
21532 char *kwnames[] = {
21533 (char *) "self", NULL
21534 };
21535
21536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21538 if (SWIG_arg_fail(1)) SWIG_fail;
21539 {
21540 PyThreadState* __tstate = wxPyBeginAllowThreads();
21541 result = (arg1)->GetPosition();
21542
21543 wxPyEndAllowThreads(__tstate);
21544 if (PyErr_Occurred()) SWIG_fail;
21545 }
21546 {
21547 wxPoint * resultptr;
21548 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21550 }
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21558 PyObject *resultobj = NULL;
21559 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21560 int result;
21561 PyObject * obj0 = 0 ;
21562 char *kwnames[] = {
21563 (char *) "self", NULL
21564 };
21565
21566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21568 if (SWIG_arg_fail(1)) SWIG_fail;
21569 {
21570 PyThreadState* __tstate = wxPyBeginAllowThreads();
21571 result = (int)(arg1)->GetNumberOfFiles();
21572
21573 wxPyEndAllowThreads(__tstate);
21574 if (PyErr_Occurred()) SWIG_fail;
21575 }
21576 {
21577 resultobj = SWIG_From_int(static_cast<int >(result));
21578 }
21579 return resultobj;
21580 fail:
21581 return NULL;
21582 }
21583
21584
21585 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21586 PyObject *resultobj = NULL;
21587 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21588 PyObject *result;
21589 PyObject * obj0 = 0 ;
21590 char *kwnames[] = {
21591 (char *) "self", NULL
21592 };
21593
21594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21596 if (SWIG_arg_fail(1)) SWIG_fail;
21597 {
21598 PyThreadState* __tstate = wxPyBeginAllowThreads();
21599 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21600
21601 wxPyEndAllowThreads(__tstate);
21602 if (PyErr_Occurred()) SWIG_fail;
21603 }
21604 resultobj = result;
21605 return resultobj;
21606 fail:
21607 return NULL;
21608 }
21609
21610
21611 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21612 PyObject *obj;
21613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21614 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21615 Py_INCREF(obj);
21616 return Py_BuildValue((char *)"");
21617 }
21618 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21619 PyObject *resultobj = NULL;
21620 int arg1 = (int) 0 ;
21621 wxUpdateUIEvent *result;
21622 PyObject * obj0 = 0 ;
21623 char *kwnames[] = {
21624 (char *) "commandId", NULL
21625 };
21626
21627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21628 if (obj0) {
21629 {
21630 arg1 = static_cast<int >(SWIG_As_int(obj0));
21631 if (SWIG_arg_fail(1)) SWIG_fail;
21632 }
21633 }
21634 {
21635 PyThreadState* __tstate = wxPyBeginAllowThreads();
21636 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21637
21638 wxPyEndAllowThreads(__tstate);
21639 if (PyErr_Occurred()) SWIG_fail;
21640 }
21641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21642 return resultobj;
21643 fail:
21644 return NULL;
21645 }
21646
21647
21648 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21649 PyObject *resultobj = NULL;
21650 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21651 bool result;
21652 PyObject * obj0 = 0 ;
21653 char *kwnames[] = {
21654 (char *) "self", NULL
21655 };
21656
21657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21659 if (SWIG_arg_fail(1)) SWIG_fail;
21660 {
21661 PyThreadState* __tstate = wxPyBeginAllowThreads();
21662 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21663
21664 wxPyEndAllowThreads(__tstate);
21665 if (PyErr_Occurred()) SWIG_fail;
21666 }
21667 {
21668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21669 }
21670 return resultobj;
21671 fail:
21672 return NULL;
21673 }
21674
21675
21676 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21677 PyObject *resultobj = NULL;
21678 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21679 bool result;
21680 PyObject * obj0 = 0 ;
21681 char *kwnames[] = {
21682 (char *) "self", NULL
21683 };
21684
21685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21687 if (SWIG_arg_fail(1)) SWIG_fail;
21688 {
21689 PyThreadState* __tstate = wxPyBeginAllowThreads();
21690 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21691
21692 wxPyEndAllowThreads(__tstate);
21693 if (PyErr_Occurred()) SWIG_fail;
21694 }
21695 {
21696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21697 }
21698 return resultobj;
21699 fail:
21700 return NULL;
21701 }
21702
21703
21704 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21705 PyObject *resultobj = NULL;
21706 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21707 wxString result;
21708 PyObject * obj0 = 0 ;
21709 char *kwnames[] = {
21710 (char *) "self", NULL
21711 };
21712
21713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21715 if (SWIG_arg_fail(1)) SWIG_fail;
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 {
21724 #if wxUSE_UNICODE
21725 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21726 #else
21727 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21728 #endif
21729 }
21730 return resultobj;
21731 fail:
21732 return NULL;
21733 }
21734
21735
21736 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj = NULL;
21738 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21739 bool result;
21740 PyObject * obj0 = 0 ;
21741 char *kwnames[] = {
21742 (char *) "self", NULL
21743 };
21744
21745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21747 if (SWIG_arg_fail(1)) SWIG_fail;
21748 {
21749 PyThreadState* __tstate = wxPyBeginAllowThreads();
21750 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21751
21752 wxPyEndAllowThreads(__tstate);
21753 if (PyErr_Occurred()) SWIG_fail;
21754 }
21755 {
21756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21757 }
21758 return resultobj;
21759 fail:
21760 return NULL;
21761 }
21762
21763
21764 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21765 PyObject *resultobj = NULL;
21766 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21767 bool result;
21768 PyObject * obj0 = 0 ;
21769 char *kwnames[] = {
21770 (char *) "self", NULL
21771 };
21772
21773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21775 if (SWIG_arg_fail(1)) SWIG_fail;
21776 {
21777 PyThreadState* __tstate = wxPyBeginAllowThreads();
21778 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21779
21780 wxPyEndAllowThreads(__tstate);
21781 if (PyErr_Occurred()) SWIG_fail;
21782 }
21783 {
21784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21785 }
21786 return resultobj;
21787 fail:
21788 return NULL;
21789 }
21790
21791
21792 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21793 PyObject *resultobj = NULL;
21794 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21795 bool result;
21796 PyObject * obj0 = 0 ;
21797 char *kwnames[] = {
21798 (char *) "self", NULL
21799 };
21800
21801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21803 if (SWIG_arg_fail(1)) SWIG_fail;
21804 {
21805 PyThreadState* __tstate = wxPyBeginAllowThreads();
21806 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21807
21808 wxPyEndAllowThreads(__tstate);
21809 if (PyErr_Occurred()) SWIG_fail;
21810 }
21811 {
21812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21813 }
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21821 PyObject *resultobj = NULL;
21822 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21823 bool arg2 ;
21824 PyObject * obj0 = 0 ;
21825 PyObject * obj1 = 0 ;
21826 char *kwnames[] = {
21827 (char *) "self",(char *) "check", NULL
21828 };
21829
21830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21832 if (SWIG_arg_fail(1)) SWIG_fail;
21833 {
21834 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21835 if (SWIG_arg_fail(2)) SWIG_fail;
21836 }
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 (arg1)->Check(arg2);
21840
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 Py_INCREF(Py_None); resultobj = Py_None;
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21852 PyObject *resultobj = NULL;
21853 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21854 bool arg2 ;
21855 PyObject * obj0 = 0 ;
21856 PyObject * obj1 = 0 ;
21857 char *kwnames[] = {
21858 (char *) "self",(char *) "enable", NULL
21859 };
21860
21861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21863 if (SWIG_arg_fail(1)) SWIG_fail;
21864 {
21865 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21866 if (SWIG_arg_fail(2)) SWIG_fail;
21867 }
21868 {
21869 PyThreadState* __tstate = wxPyBeginAllowThreads();
21870 (arg1)->Enable(arg2);
21871
21872 wxPyEndAllowThreads(__tstate);
21873 if (PyErr_Occurred()) SWIG_fail;
21874 }
21875 Py_INCREF(Py_None); resultobj = Py_None;
21876 return resultobj;
21877 fail:
21878 return NULL;
21879 }
21880
21881
21882 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21883 PyObject *resultobj = NULL;
21884 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21885 wxString *arg2 = 0 ;
21886 bool temp2 = false ;
21887 PyObject * obj0 = 0 ;
21888 PyObject * obj1 = 0 ;
21889 char *kwnames[] = {
21890 (char *) "self",(char *) "text", NULL
21891 };
21892
21893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21895 if (SWIG_arg_fail(1)) SWIG_fail;
21896 {
21897 arg2 = wxString_in_helper(obj1);
21898 if (arg2 == NULL) SWIG_fail;
21899 temp2 = true;
21900 }
21901 {
21902 PyThreadState* __tstate = wxPyBeginAllowThreads();
21903 (arg1)->SetText((wxString const &)*arg2);
21904
21905 wxPyEndAllowThreads(__tstate);
21906 if (PyErr_Occurred()) SWIG_fail;
21907 }
21908 Py_INCREF(Py_None); resultobj = Py_None;
21909 {
21910 if (temp2)
21911 delete arg2;
21912 }
21913 return resultobj;
21914 fail:
21915 {
21916 if (temp2)
21917 delete arg2;
21918 }
21919 return NULL;
21920 }
21921
21922
21923 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21924 PyObject *resultobj = NULL;
21925 long arg1 ;
21926 PyObject * obj0 = 0 ;
21927 char *kwnames[] = {
21928 (char *) "updateInterval", NULL
21929 };
21930
21931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21932 {
21933 arg1 = static_cast<long >(SWIG_As_long(obj0));
21934 if (SWIG_arg_fail(1)) SWIG_fail;
21935 }
21936 {
21937 PyThreadState* __tstate = wxPyBeginAllowThreads();
21938 wxUpdateUIEvent::SetUpdateInterval(arg1);
21939
21940 wxPyEndAllowThreads(__tstate);
21941 if (PyErr_Occurred()) SWIG_fail;
21942 }
21943 Py_INCREF(Py_None); resultobj = Py_None;
21944 return resultobj;
21945 fail:
21946 return NULL;
21947 }
21948
21949
21950 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21951 PyObject *resultobj = NULL;
21952 long result;
21953 char *kwnames[] = {
21954 NULL
21955 };
21956
21957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21958 {
21959 PyThreadState* __tstate = wxPyBeginAllowThreads();
21960 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21961
21962 wxPyEndAllowThreads(__tstate);
21963 if (PyErr_Occurred()) SWIG_fail;
21964 }
21965 {
21966 resultobj = SWIG_From_long(static_cast<long >(result));
21967 }
21968 return resultobj;
21969 fail:
21970 return NULL;
21971 }
21972
21973
21974 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21975 PyObject *resultobj = NULL;
21976 wxWindow *arg1 = (wxWindow *) 0 ;
21977 bool result;
21978 PyObject * obj0 = 0 ;
21979 char *kwnames[] = {
21980 (char *) "win", NULL
21981 };
21982
21983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21985 if (SWIG_arg_fail(1)) SWIG_fail;
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21989
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
22003 PyObject *resultobj = NULL;
22004 char *kwnames[] = {
22005 NULL
22006 };
22007
22008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
22009 {
22010 PyThreadState* __tstate = wxPyBeginAllowThreads();
22011 wxUpdateUIEvent::ResetUpdateTime();
22012
22013 wxPyEndAllowThreads(__tstate);
22014 if (PyErr_Occurred()) SWIG_fail;
22015 }
22016 Py_INCREF(Py_None); resultobj = Py_None;
22017 return resultobj;
22018 fail:
22019 return NULL;
22020 }
22021
22022
22023 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22024 PyObject *resultobj = NULL;
22025 wxUpdateUIMode arg1 ;
22026 PyObject * obj0 = 0 ;
22027 char *kwnames[] = {
22028 (char *) "mode", NULL
22029 };
22030
22031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
22032 {
22033 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
22034 if (SWIG_arg_fail(1)) SWIG_fail;
22035 }
22036 {
22037 PyThreadState* __tstate = wxPyBeginAllowThreads();
22038 wxUpdateUIEvent::SetMode(arg1);
22039
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 Py_INCREF(Py_None); resultobj = Py_None;
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj = NULL;
22052 wxUpdateUIMode result;
22053 char *kwnames[] = {
22054 NULL
22055 };
22056
22057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
22058 {
22059 PyThreadState* __tstate = wxPyBeginAllowThreads();
22060 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
22061
22062 wxPyEndAllowThreads(__tstate);
22063 if (PyErr_Occurred()) SWIG_fail;
22064 }
22065 resultobj = SWIG_From_int((result));
22066 return resultobj;
22067 fail:
22068 return NULL;
22069 }
22070
22071
22072 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
22073 PyObject *obj;
22074 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22075 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
22076 Py_INCREF(obj);
22077 return Py_BuildValue((char *)"");
22078 }
22079 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22080 PyObject *resultobj = NULL;
22081 wxSysColourChangedEvent *result;
22082 char *kwnames[] = {
22083 NULL
22084 };
22085
22086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22090
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22102 PyObject *obj;
22103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22104 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22105 Py_INCREF(obj);
22106 return Py_BuildValue((char *)"");
22107 }
22108 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22109 PyObject *resultobj = NULL;
22110 int arg1 = (int) 0 ;
22111 wxWindow *arg2 = (wxWindow *) NULL ;
22112 wxMouseCaptureChangedEvent *result;
22113 PyObject * obj0 = 0 ;
22114 PyObject * obj1 = 0 ;
22115 char *kwnames[] = {
22116 (char *) "winid",(char *) "gainedCapture", NULL
22117 };
22118
22119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22120 if (obj0) {
22121 {
22122 arg1 = static_cast<int >(SWIG_As_int(obj0));
22123 if (SWIG_arg_fail(1)) SWIG_fail;
22124 }
22125 }
22126 if (obj1) {
22127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22128 if (SWIG_arg_fail(2)) SWIG_fail;
22129 }
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22133
22134 wxPyEndAllowThreads(__tstate);
22135 if (PyErr_Occurred()) SWIG_fail;
22136 }
22137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22138 return resultobj;
22139 fail:
22140 return NULL;
22141 }
22142
22143
22144 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22145 PyObject *resultobj = NULL;
22146 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22147 wxWindow *result;
22148 PyObject * obj0 = 0 ;
22149 char *kwnames[] = {
22150 (char *) "self", NULL
22151 };
22152
22153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22155 if (SWIG_arg_fail(1)) SWIG_fail;
22156 {
22157 PyThreadState* __tstate = wxPyBeginAllowThreads();
22158 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22159
22160 wxPyEndAllowThreads(__tstate);
22161 if (PyErr_Occurred()) SWIG_fail;
22162 }
22163 {
22164 resultobj = wxPyMake_wxObject(result, (bool)0);
22165 }
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22173 PyObject *obj;
22174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22175 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22176 Py_INCREF(obj);
22177 return Py_BuildValue((char *)"");
22178 }
22179 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22180 PyObject *resultobj = NULL;
22181 wxDisplayChangedEvent *result;
22182 char *kwnames[] = {
22183 NULL
22184 };
22185
22186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22187 {
22188 PyThreadState* __tstate = wxPyBeginAllowThreads();
22189 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22190
22191 wxPyEndAllowThreads(__tstate);
22192 if (PyErr_Occurred()) SWIG_fail;
22193 }
22194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22195 return resultobj;
22196 fail:
22197 return NULL;
22198 }
22199
22200
22201 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22202 PyObject *obj;
22203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22204 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22205 Py_INCREF(obj);
22206 return Py_BuildValue((char *)"");
22207 }
22208 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22209 PyObject *resultobj = NULL;
22210 int arg1 = (int) 0 ;
22211 wxPaletteChangedEvent *result;
22212 PyObject * obj0 = 0 ;
22213 char *kwnames[] = {
22214 (char *) "id", NULL
22215 };
22216
22217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22218 if (obj0) {
22219 {
22220 arg1 = static_cast<int >(SWIG_As_int(obj0));
22221 if (SWIG_arg_fail(1)) SWIG_fail;
22222 }
22223 }
22224 {
22225 PyThreadState* __tstate = wxPyBeginAllowThreads();
22226 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22227
22228 wxPyEndAllowThreads(__tstate);
22229 if (PyErr_Occurred()) SWIG_fail;
22230 }
22231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22239 PyObject *resultobj = NULL;
22240 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22241 wxWindow *arg2 = (wxWindow *) 0 ;
22242 PyObject * obj0 = 0 ;
22243 PyObject * obj1 = 0 ;
22244 char *kwnames[] = {
22245 (char *) "self",(char *) "win", NULL
22246 };
22247
22248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22250 if (SWIG_arg_fail(1)) SWIG_fail;
22251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22252 if (SWIG_arg_fail(2)) SWIG_fail;
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 (arg1)->SetChangedWindow(arg2);
22256
22257 wxPyEndAllowThreads(__tstate);
22258 if (PyErr_Occurred()) SWIG_fail;
22259 }
22260 Py_INCREF(Py_None); resultobj = Py_None;
22261 return resultobj;
22262 fail:
22263 return NULL;
22264 }
22265
22266
22267 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22268 PyObject *resultobj = NULL;
22269 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22270 wxWindow *result;
22271 PyObject * obj0 = 0 ;
22272 char *kwnames[] = {
22273 (char *) "self", NULL
22274 };
22275
22276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22278 if (SWIG_arg_fail(1)) SWIG_fail;
22279 {
22280 PyThreadState* __tstate = wxPyBeginAllowThreads();
22281 result = (wxWindow *)(arg1)->GetChangedWindow();
22282
22283 wxPyEndAllowThreads(__tstate);
22284 if (PyErr_Occurred()) SWIG_fail;
22285 }
22286 {
22287 resultobj = wxPyMake_wxObject(result, (bool)0);
22288 }
22289 return resultobj;
22290 fail:
22291 return NULL;
22292 }
22293
22294
22295 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22296 PyObject *obj;
22297 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22298 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22299 Py_INCREF(obj);
22300 return Py_BuildValue((char *)"");
22301 }
22302 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22303 PyObject *resultobj = NULL;
22304 int arg1 = (int) 0 ;
22305 wxQueryNewPaletteEvent *result;
22306 PyObject * obj0 = 0 ;
22307 char *kwnames[] = {
22308 (char *) "winid", NULL
22309 };
22310
22311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22312 if (obj0) {
22313 {
22314 arg1 = static_cast<int >(SWIG_As_int(obj0));
22315 if (SWIG_arg_fail(1)) SWIG_fail;
22316 }
22317 }
22318 {
22319 PyThreadState* __tstate = wxPyBeginAllowThreads();
22320 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22321
22322 wxPyEndAllowThreads(__tstate);
22323 if (PyErr_Occurred()) SWIG_fail;
22324 }
22325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22326 return resultobj;
22327 fail:
22328 return NULL;
22329 }
22330
22331
22332 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22333 PyObject *resultobj = NULL;
22334 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22335 bool arg2 ;
22336 PyObject * obj0 = 0 ;
22337 PyObject * obj1 = 0 ;
22338 char *kwnames[] = {
22339 (char *) "self",(char *) "realized", NULL
22340 };
22341
22342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22344 if (SWIG_arg_fail(1)) SWIG_fail;
22345 {
22346 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22347 if (SWIG_arg_fail(2)) SWIG_fail;
22348 }
22349 {
22350 PyThreadState* __tstate = wxPyBeginAllowThreads();
22351 (arg1)->SetPaletteRealized(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_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22364 PyObject *resultobj = NULL;
22365 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22366 bool result;
22367 PyObject * obj0 = 0 ;
22368 char *kwnames[] = {
22369 (char *) "self", NULL
22370 };
22371
22372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22374 if (SWIG_arg_fail(1)) SWIG_fail;
22375 {
22376 PyThreadState* __tstate = wxPyBeginAllowThreads();
22377 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22378
22379 wxPyEndAllowThreads(__tstate);
22380 if (PyErr_Occurred()) SWIG_fail;
22381 }
22382 {
22383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22384 }
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22392 PyObject *obj;
22393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22394 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22395 Py_INCREF(obj);
22396 return Py_BuildValue((char *)"");
22397 }
22398 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22399 PyObject *resultobj = NULL;
22400 wxNavigationKeyEvent *result;
22401 char *kwnames[] = {
22402 NULL
22403 };
22404
22405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22406 {
22407 PyThreadState* __tstate = wxPyBeginAllowThreads();
22408 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22409
22410 wxPyEndAllowThreads(__tstate);
22411 if (PyErr_Occurred()) SWIG_fail;
22412 }
22413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22421 PyObject *resultobj = NULL;
22422 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22423 bool result;
22424 PyObject * obj0 = 0 ;
22425 char *kwnames[] = {
22426 (char *) "self", NULL
22427 };
22428
22429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22431 if (SWIG_arg_fail(1)) SWIG_fail;
22432 {
22433 PyThreadState* __tstate = wxPyBeginAllowThreads();
22434 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22435
22436 wxPyEndAllowThreads(__tstate);
22437 if (PyErr_Occurred()) SWIG_fail;
22438 }
22439 {
22440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22441 }
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22449 PyObject *resultobj = NULL;
22450 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22451 bool arg2 ;
22452 PyObject * obj0 = 0 ;
22453 PyObject * obj1 = 0 ;
22454 char *kwnames[] = {
22455 (char *) "self",(char *) "forward", NULL
22456 };
22457
22458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22460 if (SWIG_arg_fail(1)) SWIG_fail;
22461 {
22462 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22463 if (SWIG_arg_fail(2)) SWIG_fail;
22464 }
22465 {
22466 PyThreadState* __tstate = wxPyBeginAllowThreads();
22467 (arg1)->SetDirection(arg2);
22468
22469 wxPyEndAllowThreads(__tstate);
22470 if (PyErr_Occurred()) SWIG_fail;
22471 }
22472 Py_INCREF(Py_None); resultobj = Py_None;
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22480 PyObject *resultobj = NULL;
22481 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22482 bool result;
22483 PyObject * obj0 = 0 ;
22484 char *kwnames[] = {
22485 (char *) "self", NULL
22486 };
22487
22488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22490 if (SWIG_arg_fail(1)) SWIG_fail;
22491 {
22492 PyThreadState* __tstate = wxPyBeginAllowThreads();
22493 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22494
22495 wxPyEndAllowThreads(__tstate);
22496 if (PyErr_Occurred()) SWIG_fail;
22497 }
22498 {
22499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22500 }
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22508 PyObject *resultobj = NULL;
22509 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22510 bool arg2 ;
22511 PyObject * obj0 = 0 ;
22512 PyObject * obj1 = 0 ;
22513 char *kwnames[] = {
22514 (char *) "self",(char *) "ischange", NULL
22515 };
22516
22517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22519 if (SWIG_arg_fail(1)) SWIG_fail;
22520 {
22521 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22522 if (SWIG_arg_fail(2)) SWIG_fail;
22523 }
22524 {
22525 PyThreadState* __tstate = wxPyBeginAllowThreads();
22526 (arg1)->SetWindowChange(arg2);
22527
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 Py_INCREF(Py_None); resultobj = Py_None;
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22539 PyObject *resultobj = NULL;
22540 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22541 bool result;
22542 PyObject * obj0 = 0 ;
22543 char *kwnames[] = {
22544 (char *) "self", NULL
22545 };
22546
22547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22549 if (SWIG_arg_fail(1)) SWIG_fail;
22550 {
22551 PyThreadState* __tstate = wxPyBeginAllowThreads();
22552 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22553
22554 wxPyEndAllowThreads(__tstate);
22555 if (PyErr_Occurred()) SWIG_fail;
22556 }
22557 {
22558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22559 }
22560 return resultobj;
22561 fail:
22562 return NULL;
22563 }
22564
22565
22566 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22567 PyObject *resultobj = NULL;
22568 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22569 bool arg2 ;
22570 PyObject * obj0 = 0 ;
22571 PyObject * obj1 = 0 ;
22572 char *kwnames[] = {
22573 (char *) "self",(char *) "bIs", NULL
22574 };
22575
22576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22578 if (SWIG_arg_fail(1)) SWIG_fail;
22579 {
22580 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22581 if (SWIG_arg_fail(2)) SWIG_fail;
22582 }
22583 {
22584 PyThreadState* __tstate = wxPyBeginAllowThreads();
22585 (arg1)->SetFromTab(arg2);
22586
22587 wxPyEndAllowThreads(__tstate);
22588 if (PyErr_Occurred()) SWIG_fail;
22589 }
22590 Py_INCREF(Py_None); resultobj = Py_None;
22591 return resultobj;
22592 fail:
22593 return NULL;
22594 }
22595
22596
22597 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22598 PyObject *resultobj = NULL;
22599 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22600 long arg2 ;
22601 PyObject * obj0 = 0 ;
22602 PyObject * obj1 = 0 ;
22603 char *kwnames[] = {
22604 (char *) "self",(char *) "flags", NULL
22605 };
22606
22607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22609 if (SWIG_arg_fail(1)) SWIG_fail;
22610 {
22611 arg2 = static_cast<long >(SWIG_As_long(obj1));
22612 if (SWIG_arg_fail(2)) SWIG_fail;
22613 }
22614 {
22615 PyThreadState* __tstate = wxPyBeginAllowThreads();
22616 (arg1)->SetFlags(arg2);
22617
22618 wxPyEndAllowThreads(__tstate);
22619 if (PyErr_Occurred()) SWIG_fail;
22620 }
22621 Py_INCREF(Py_None); resultobj = Py_None;
22622 return resultobj;
22623 fail:
22624 return NULL;
22625 }
22626
22627
22628 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22629 PyObject *resultobj = NULL;
22630 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22631 wxWindow *result;
22632 PyObject * obj0 = 0 ;
22633 char *kwnames[] = {
22634 (char *) "self", NULL
22635 };
22636
22637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22639 if (SWIG_arg_fail(1)) SWIG_fail;
22640 {
22641 PyThreadState* __tstate = wxPyBeginAllowThreads();
22642 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22643
22644 wxPyEndAllowThreads(__tstate);
22645 if (PyErr_Occurred()) SWIG_fail;
22646 }
22647 {
22648 resultobj = wxPyMake_wxObject(result, (bool)0);
22649 }
22650 return resultobj;
22651 fail:
22652 return NULL;
22653 }
22654
22655
22656 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22657 PyObject *resultobj = NULL;
22658 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22659 wxWindow *arg2 = (wxWindow *) 0 ;
22660 PyObject * obj0 = 0 ;
22661 PyObject * obj1 = 0 ;
22662 char *kwnames[] = {
22663 (char *) "self",(char *) "win", NULL
22664 };
22665
22666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22668 if (SWIG_arg_fail(1)) SWIG_fail;
22669 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22670 if (SWIG_arg_fail(2)) SWIG_fail;
22671 {
22672 PyThreadState* __tstate = wxPyBeginAllowThreads();
22673 (arg1)->SetCurrentFocus(arg2);
22674
22675 wxPyEndAllowThreads(__tstate);
22676 if (PyErr_Occurred()) SWIG_fail;
22677 }
22678 Py_INCREF(Py_None); resultobj = Py_None;
22679 return resultobj;
22680 fail:
22681 return NULL;
22682 }
22683
22684
22685 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22686 PyObject *obj;
22687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22688 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22689 Py_INCREF(obj);
22690 return Py_BuildValue((char *)"");
22691 }
22692 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22693 PyObject *resultobj = NULL;
22694 wxWindow *arg1 = (wxWindow *) NULL ;
22695 wxWindowCreateEvent *result;
22696 PyObject * obj0 = 0 ;
22697 char *kwnames[] = {
22698 (char *) "win", NULL
22699 };
22700
22701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22702 if (obj0) {
22703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22704 if (SWIG_arg_fail(1)) SWIG_fail;
22705 }
22706 {
22707 PyThreadState* __tstate = wxPyBeginAllowThreads();
22708 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22709
22710 wxPyEndAllowThreads(__tstate);
22711 if (PyErr_Occurred()) SWIG_fail;
22712 }
22713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22714 return resultobj;
22715 fail:
22716 return NULL;
22717 }
22718
22719
22720 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22721 PyObject *resultobj = NULL;
22722 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22723 wxWindow *result;
22724 PyObject * obj0 = 0 ;
22725 char *kwnames[] = {
22726 (char *) "self", NULL
22727 };
22728
22729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22731 if (SWIG_arg_fail(1)) SWIG_fail;
22732 {
22733 PyThreadState* __tstate = wxPyBeginAllowThreads();
22734 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22735
22736 wxPyEndAllowThreads(__tstate);
22737 if (PyErr_Occurred()) SWIG_fail;
22738 }
22739 {
22740 resultobj = wxPyMake_wxObject(result, (bool)0);
22741 }
22742 return resultobj;
22743 fail:
22744 return NULL;
22745 }
22746
22747
22748 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22749 PyObject *obj;
22750 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22751 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22752 Py_INCREF(obj);
22753 return Py_BuildValue((char *)"");
22754 }
22755 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22756 PyObject *resultobj = NULL;
22757 wxWindow *arg1 = (wxWindow *) NULL ;
22758 wxWindowDestroyEvent *result;
22759 PyObject * obj0 = 0 ;
22760 char *kwnames[] = {
22761 (char *) "win", NULL
22762 };
22763
22764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22765 if (obj0) {
22766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22767 if (SWIG_arg_fail(1)) SWIG_fail;
22768 }
22769 {
22770 PyThreadState* __tstate = wxPyBeginAllowThreads();
22771 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22772
22773 wxPyEndAllowThreads(__tstate);
22774 if (PyErr_Occurred()) SWIG_fail;
22775 }
22776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22777 return resultobj;
22778 fail:
22779 return NULL;
22780 }
22781
22782
22783 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22784 PyObject *resultobj = NULL;
22785 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22786 wxWindow *result;
22787 PyObject * obj0 = 0 ;
22788 char *kwnames[] = {
22789 (char *) "self", NULL
22790 };
22791
22792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22794 if (SWIG_arg_fail(1)) SWIG_fail;
22795 {
22796 PyThreadState* __tstate = wxPyBeginAllowThreads();
22797 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22798
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 {
22803 resultobj = wxPyMake_wxObject(result, (bool)0);
22804 }
22805 return resultobj;
22806 fail:
22807 return NULL;
22808 }
22809
22810
22811 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22812 PyObject *obj;
22813 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22814 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22815 Py_INCREF(obj);
22816 return Py_BuildValue((char *)"");
22817 }
22818 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22819 PyObject *resultobj = NULL;
22820 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22821 int arg2 = (int) 0 ;
22822 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22823 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22824 wxContextMenuEvent *result;
22825 wxPoint temp3 ;
22826 PyObject * obj0 = 0 ;
22827 PyObject * obj1 = 0 ;
22828 PyObject * obj2 = 0 ;
22829 char *kwnames[] = {
22830 (char *) "type",(char *) "winid",(char *) "pt", NULL
22831 };
22832
22833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22834 if (obj0) {
22835 {
22836 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22837 if (SWIG_arg_fail(1)) SWIG_fail;
22838 }
22839 }
22840 if (obj1) {
22841 {
22842 arg2 = static_cast<int >(SWIG_As_int(obj1));
22843 if (SWIG_arg_fail(2)) SWIG_fail;
22844 }
22845 }
22846 if (obj2) {
22847 {
22848 arg3 = &temp3;
22849 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22850 }
22851 }
22852 {
22853 PyThreadState* __tstate = wxPyBeginAllowThreads();
22854 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22855
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22867 PyObject *resultobj = NULL;
22868 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22869 wxPoint *result;
22870 PyObject * obj0 = 0 ;
22871 char *kwnames[] = {
22872 (char *) "self", NULL
22873 };
22874
22875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22877 if (SWIG_arg_fail(1)) SWIG_fail;
22878 {
22879 PyThreadState* __tstate = wxPyBeginAllowThreads();
22880 {
22881 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22882 result = (wxPoint *) &_result_ref;
22883 }
22884
22885 wxPyEndAllowThreads(__tstate);
22886 if (PyErr_Occurred()) SWIG_fail;
22887 }
22888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22889 return resultobj;
22890 fail:
22891 return NULL;
22892 }
22893
22894
22895 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22896 PyObject *resultobj = NULL;
22897 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22898 wxPoint *arg2 = 0 ;
22899 wxPoint temp2 ;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902 char *kwnames[] = {
22903 (char *) "self",(char *) "pos", NULL
22904 };
22905
22906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 {
22910 arg2 = &temp2;
22911 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22912 }
22913 {
22914 PyThreadState* __tstate = wxPyBeginAllowThreads();
22915 (arg1)->SetPosition((wxPoint const &)*arg2);
22916
22917 wxPyEndAllowThreads(__tstate);
22918 if (PyErr_Occurred()) SWIG_fail;
22919 }
22920 Py_INCREF(Py_None); resultobj = Py_None;
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22928 PyObject *obj;
22929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22930 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22931 Py_INCREF(obj);
22932 return Py_BuildValue((char *)"");
22933 }
22934 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22935 PyObject *resultobj = NULL;
22936 wxIdleEvent *result;
22937 char *kwnames[] = {
22938 NULL
22939 };
22940
22941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22942 {
22943 PyThreadState* __tstate = wxPyBeginAllowThreads();
22944 result = (wxIdleEvent *)new wxIdleEvent();
22945
22946 wxPyEndAllowThreads(__tstate);
22947 if (PyErr_Occurred()) SWIG_fail;
22948 }
22949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22950 return resultobj;
22951 fail:
22952 return NULL;
22953 }
22954
22955
22956 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22957 PyObject *resultobj = NULL;
22958 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22959 bool arg2 = (bool) true ;
22960 PyObject * obj0 = 0 ;
22961 PyObject * obj1 = 0 ;
22962 char *kwnames[] = {
22963 (char *) "self",(char *) "needMore", NULL
22964 };
22965
22966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22968 if (SWIG_arg_fail(1)) SWIG_fail;
22969 if (obj1) {
22970 {
22971 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22972 if (SWIG_arg_fail(2)) SWIG_fail;
22973 }
22974 }
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 (arg1)->RequestMore(arg2);
22978
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 Py_INCREF(Py_None); resultobj = Py_None;
22983 return resultobj;
22984 fail:
22985 return NULL;
22986 }
22987
22988
22989 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22990 PyObject *resultobj = NULL;
22991 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22992 bool result;
22993 PyObject * obj0 = 0 ;
22994 char *kwnames[] = {
22995 (char *) "self", NULL
22996 };
22997
22998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23000 if (SWIG_arg_fail(1)) SWIG_fail;
23001 {
23002 PyThreadState* __tstate = wxPyBeginAllowThreads();
23003 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
23004
23005 wxPyEndAllowThreads(__tstate);
23006 if (PyErr_Occurred()) SWIG_fail;
23007 }
23008 {
23009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23010 }
23011 return resultobj;
23012 fail:
23013 return NULL;
23014 }
23015
23016
23017 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
23018 PyObject *resultobj = NULL;
23019 wxIdleMode arg1 ;
23020 PyObject * obj0 = 0 ;
23021 char *kwnames[] = {
23022 (char *) "mode", NULL
23023 };
23024
23025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
23026 {
23027 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
23028 if (SWIG_arg_fail(1)) SWIG_fail;
23029 }
23030 {
23031 PyThreadState* __tstate = wxPyBeginAllowThreads();
23032 wxIdleEvent::SetMode(arg1);
23033
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 Py_INCREF(Py_None); resultobj = Py_None;
23038 return resultobj;
23039 fail:
23040 return NULL;
23041 }
23042
23043
23044 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
23045 PyObject *resultobj = NULL;
23046 wxIdleMode result;
23047 char *kwnames[] = {
23048 NULL
23049 };
23050
23051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
23052 {
23053 PyThreadState* __tstate = wxPyBeginAllowThreads();
23054 result = (wxIdleMode)wxIdleEvent::GetMode();
23055
23056 wxPyEndAllowThreads(__tstate);
23057 if (PyErr_Occurred()) SWIG_fail;
23058 }
23059 resultobj = SWIG_From_int((result));
23060 return resultobj;
23061 fail:
23062 return NULL;
23063 }
23064
23065
23066 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
23067 PyObject *resultobj = NULL;
23068 wxWindow *arg1 = (wxWindow *) 0 ;
23069 bool result;
23070 PyObject * obj0 = 0 ;
23071 char *kwnames[] = {
23072 (char *) "win", NULL
23073 };
23074
23075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
23076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23077 if (SWIG_arg_fail(1)) SWIG_fail;
23078 {
23079 PyThreadState* __tstate = wxPyBeginAllowThreads();
23080 result = (bool)wxIdleEvent::CanSend(arg1);
23081
23082 wxPyEndAllowThreads(__tstate);
23083 if (PyErr_Occurred()) SWIG_fail;
23084 }
23085 {
23086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23087 }
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23095 PyObject *obj;
23096 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23097 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23098 Py_INCREF(obj);
23099 return Py_BuildValue((char *)"");
23100 }
23101 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23102 PyObject *resultobj = NULL;
23103 int arg1 = (int) 0 ;
23104 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23105 wxPyEvent *result;
23106 PyObject * obj0 = 0 ;
23107 PyObject * obj1 = 0 ;
23108 char *kwnames[] = {
23109 (char *) "winid",(char *) "eventType", NULL
23110 };
23111
23112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23113 if (obj0) {
23114 {
23115 arg1 = static_cast<int >(SWIG_As_int(obj0));
23116 if (SWIG_arg_fail(1)) SWIG_fail;
23117 }
23118 }
23119 if (obj1) {
23120 {
23121 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23122 if (SWIG_arg_fail(2)) SWIG_fail;
23123 }
23124 }
23125 {
23126 PyThreadState* __tstate = wxPyBeginAllowThreads();
23127 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23128
23129 wxPyEndAllowThreads(__tstate);
23130 if (PyErr_Occurred()) SWIG_fail;
23131 }
23132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23133 return resultobj;
23134 fail:
23135 return NULL;
23136 }
23137
23138
23139 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23140 PyObject *resultobj = NULL;
23141 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23142 PyObject * obj0 = 0 ;
23143 char *kwnames[] = {
23144 (char *) "self", NULL
23145 };
23146
23147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23149 if (SWIG_arg_fail(1)) SWIG_fail;
23150 {
23151 PyThreadState* __tstate = wxPyBeginAllowThreads();
23152 delete arg1;
23153
23154 wxPyEndAllowThreads(__tstate);
23155 if (PyErr_Occurred()) SWIG_fail;
23156 }
23157 Py_INCREF(Py_None); resultobj = Py_None;
23158 return resultobj;
23159 fail:
23160 return NULL;
23161 }
23162
23163
23164 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23165 PyObject *resultobj = NULL;
23166 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23167 PyObject *arg2 = (PyObject *) 0 ;
23168 PyObject * obj0 = 0 ;
23169 PyObject * obj1 = 0 ;
23170 char *kwnames[] = {
23171 (char *) "self",(char *) "self", NULL
23172 };
23173
23174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23176 if (SWIG_arg_fail(1)) SWIG_fail;
23177 arg2 = obj1;
23178 {
23179 PyThreadState* __tstate = wxPyBeginAllowThreads();
23180 (arg1)->SetSelf(arg2);
23181
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 Py_INCREF(Py_None); resultobj = Py_None;
23186 return resultobj;
23187 fail:
23188 return NULL;
23189 }
23190
23191
23192 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23193 PyObject *resultobj = NULL;
23194 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23195 PyObject *result;
23196 PyObject * obj0 = 0 ;
23197 char *kwnames[] = {
23198 (char *) "self", NULL
23199 };
23200
23201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23203 if (SWIG_arg_fail(1)) SWIG_fail;
23204 {
23205 PyThreadState* __tstate = wxPyBeginAllowThreads();
23206 result = (PyObject *)(arg1)->GetSelf();
23207
23208 wxPyEndAllowThreads(__tstate);
23209 if (PyErr_Occurred()) SWIG_fail;
23210 }
23211 resultobj = result;
23212 return resultobj;
23213 fail:
23214 return NULL;
23215 }
23216
23217
23218 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23219 PyObject *obj;
23220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23221 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23222 Py_INCREF(obj);
23223 return Py_BuildValue((char *)"");
23224 }
23225 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23226 PyObject *resultobj = NULL;
23227 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23228 int arg2 = (int) 0 ;
23229 wxPyCommandEvent *result;
23230 PyObject * obj0 = 0 ;
23231 PyObject * obj1 = 0 ;
23232 char *kwnames[] = {
23233 (char *) "eventType",(char *) "id", NULL
23234 };
23235
23236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23237 if (obj0) {
23238 {
23239 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23240 if (SWIG_arg_fail(1)) SWIG_fail;
23241 }
23242 }
23243 if (obj1) {
23244 {
23245 arg2 = static_cast<int >(SWIG_As_int(obj1));
23246 if (SWIG_arg_fail(2)) SWIG_fail;
23247 }
23248 }
23249 {
23250 PyThreadState* __tstate = wxPyBeginAllowThreads();
23251 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23252
23253 wxPyEndAllowThreads(__tstate);
23254 if (PyErr_Occurred()) SWIG_fail;
23255 }
23256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23257 return resultobj;
23258 fail:
23259 return NULL;
23260 }
23261
23262
23263 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23264 PyObject *resultobj = NULL;
23265 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23266 PyObject * obj0 = 0 ;
23267 char *kwnames[] = {
23268 (char *) "self", NULL
23269 };
23270
23271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23273 if (SWIG_arg_fail(1)) SWIG_fail;
23274 {
23275 PyThreadState* __tstate = wxPyBeginAllowThreads();
23276 delete arg1;
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_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23289 PyObject *resultobj = NULL;
23290 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23291 PyObject *arg2 = (PyObject *) 0 ;
23292 PyObject * obj0 = 0 ;
23293 PyObject * obj1 = 0 ;
23294 char *kwnames[] = {
23295 (char *) "self",(char *) "self", NULL
23296 };
23297
23298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23300 if (SWIG_arg_fail(1)) SWIG_fail;
23301 arg2 = obj1;
23302 {
23303 PyThreadState* __tstate = wxPyBeginAllowThreads();
23304 (arg1)->SetSelf(arg2);
23305
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 Py_INCREF(Py_None); resultobj = Py_None;
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23317 PyObject *resultobj = NULL;
23318 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23319 PyObject *result;
23320 PyObject * obj0 = 0 ;
23321 char *kwnames[] = {
23322 (char *) "self", NULL
23323 };
23324
23325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23327 if (SWIG_arg_fail(1)) SWIG_fail;
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 result = (PyObject *)(arg1)->GetSelf();
23331
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 resultobj = result;
23336 return resultobj;
23337 fail:
23338 return NULL;
23339 }
23340
23341
23342 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23343 PyObject *obj;
23344 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23345 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23346 Py_INCREF(obj);
23347 return Py_BuildValue((char *)"");
23348 }
23349 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23350 PyObject *resultobj = NULL;
23351 wxWindow *arg1 = (wxWindow *) 0 ;
23352 wxDateTime *arg2 = 0 ;
23353 wxEventType arg3 ;
23354 wxDateEvent *result;
23355 PyObject * obj0 = 0 ;
23356 PyObject * obj1 = 0 ;
23357 PyObject * obj2 = 0 ;
23358 char *kwnames[] = {
23359 (char *) "win",(char *) "dt",(char *) "type", NULL
23360 };
23361
23362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23364 if (SWIG_arg_fail(1)) SWIG_fail;
23365 {
23366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23367 if (SWIG_arg_fail(2)) SWIG_fail;
23368 if (arg2 == NULL) {
23369 SWIG_null_ref("wxDateTime");
23370 }
23371 if (SWIG_arg_fail(2)) SWIG_fail;
23372 }
23373 {
23374 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23375 if (SWIG_arg_fail(3)) SWIG_fail;
23376 }
23377 {
23378 PyThreadState* __tstate = wxPyBeginAllowThreads();
23379 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23380
23381 wxPyEndAllowThreads(__tstate);
23382 if (PyErr_Occurred()) SWIG_fail;
23383 }
23384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23385 return resultobj;
23386 fail:
23387 return NULL;
23388 }
23389
23390
23391 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23392 PyObject *resultobj = NULL;
23393 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23394 wxDateTime *result;
23395 PyObject * obj0 = 0 ;
23396 char *kwnames[] = {
23397 (char *) "self", NULL
23398 };
23399
23400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23402 if (SWIG_arg_fail(1)) SWIG_fail;
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 {
23406 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23407 result = (wxDateTime *) &_result_ref;
23408 }
23409
23410 wxPyEndAllowThreads(__tstate);
23411 if (PyErr_Occurred()) SWIG_fail;
23412 }
23413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23414 return resultobj;
23415 fail:
23416 return NULL;
23417 }
23418
23419
23420 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23421 PyObject *resultobj = NULL;
23422 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23423 wxDateTime *arg2 = 0 ;
23424 PyObject * obj0 = 0 ;
23425 PyObject * obj1 = 0 ;
23426 char *kwnames[] = {
23427 (char *) "self",(char *) "date", NULL
23428 };
23429
23430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23432 if (SWIG_arg_fail(1)) SWIG_fail;
23433 {
23434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23435 if (SWIG_arg_fail(2)) SWIG_fail;
23436 if (arg2 == NULL) {
23437 SWIG_null_ref("wxDateTime");
23438 }
23439 if (SWIG_arg_fail(2)) SWIG_fail;
23440 }
23441 {
23442 PyThreadState* __tstate = wxPyBeginAllowThreads();
23443 (arg1)->SetDate((wxDateTime const &)*arg2);
23444
23445 wxPyEndAllowThreads(__tstate);
23446 if (PyErr_Occurred()) SWIG_fail;
23447 }
23448 Py_INCREF(Py_None); resultobj = Py_None;
23449 return resultobj;
23450 fail:
23451 return NULL;
23452 }
23453
23454
23455 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23456 PyObject *obj;
23457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23458 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23459 Py_INCREF(obj);
23460 return Py_BuildValue((char *)"");
23461 }
23462 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23463 PyObject *resultobj = NULL;
23464 wxPyApp *result;
23465 char *kwnames[] = {
23466 NULL
23467 };
23468
23469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23470 {
23471 PyThreadState* __tstate = wxPyBeginAllowThreads();
23472 result = (wxPyApp *)new_wxPyApp();
23473
23474 wxPyEndAllowThreads(__tstate);
23475 if (PyErr_Occurred()) SWIG_fail;
23476 }
23477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23478 return resultobj;
23479 fail:
23480 return NULL;
23481 }
23482
23483
23484 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23485 PyObject *resultobj = NULL;
23486 wxPyApp *arg1 = (wxPyApp *) 0 ;
23487 PyObject * obj0 = 0 ;
23488 char *kwnames[] = {
23489 (char *) "self", NULL
23490 };
23491
23492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23494 if (SWIG_arg_fail(1)) SWIG_fail;
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 delete arg1;
23498
23499 wxPyEndAllowThreads(__tstate);
23500 if (PyErr_Occurred()) SWIG_fail;
23501 }
23502 Py_INCREF(Py_None); resultobj = Py_None;
23503 return resultobj;
23504 fail:
23505 return NULL;
23506 }
23507
23508
23509 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23510 PyObject *resultobj = NULL;
23511 wxPyApp *arg1 = (wxPyApp *) 0 ;
23512 PyObject *arg2 = (PyObject *) 0 ;
23513 PyObject *arg3 = (PyObject *) 0 ;
23514 bool arg4 ;
23515 PyObject * obj0 = 0 ;
23516 PyObject * obj1 = 0 ;
23517 PyObject * obj2 = 0 ;
23518 PyObject * obj3 = 0 ;
23519 char *kwnames[] = {
23520 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23521 };
23522
23523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23525 if (SWIG_arg_fail(1)) SWIG_fail;
23526 arg2 = obj1;
23527 arg3 = obj2;
23528 {
23529 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23530 if (SWIG_arg_fail(4)) SWIG_fail;
23531 }
23532 {
23533 PyThreadState* __tstate = wxPyBeginAllowThreads();
23534 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23535
23536 wxPyEndAllowThreads(__tstate);
23537 if (PyErr_Occurred()) SWIG_fail;
23538 }
23539 Py_INCREF(Py_None); resultobj = Py_None;
23540 return resultobj;
23541 fail:
23542 return NULL;
23543 }
23544
23545
23546 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23547 PyObject *resultobj = NULL;
23548 wxPyApp *arg1 = (wxPyApp *) 0 ;
23549 wxString result;
23550 PyObject * obj0 = 0 ;
23551 char *kwnames[] = {
23552 (char *) "self", NULL
23553 };
23554
23555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23557 if (SWIG_arg_fail(1)) SWIG_fail;
23558 {
23559 PyThreadState* __tstate = wxPyBeginAllowThreads();
23560 result = ((wxPyApp const *)arg1)->GetAppName();
23561
23562 wxPyEndAllowThreads(__tstate);
23563 if (PyErr_Occurred()) SWIG_fail;
23564 }
23565 {
23566 #if wxUSE_UNICODE
23567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23568 #else
23569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23570 #endif
23571 }
23572 return resultobj;
23573 fail:
23574 return NULL;
23575 }
23576
23577
23578 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23579 PyObject *resultobj = NULL;
23580 wxPyApp *arg1 = (wxPyApp *) 0 ;
23581 wxString *arg2 = 0 ;
23582 bool temp2 = false ;
23583 PyObject * obj0 = 0 ;
23584 PyObject * obj1 = 0 ;
23585 char *kwnames[] = {
23586 (char *) "self",(char *) "name", NULL
23587 };
23588
23589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23591 if (SWIG_arg_fail(1)) SWIG_fail;
23592 {
23593 arg2 = wxString_in_helper(obj1);
23594 if (arg2 == NULL) SWIG_fail;
23595 temp2 = true;
23596 }
23597 {
23598 PyThreadState* __tstate = wxPyBeginAllowThreads();
23599 (arg1)->SetAppName((wxString const &)*arg2);
23600
23601 wxPyEndAllowThreads(__tstate);
23602 if (PyErr_Occurred()) SWIG_fail;
23603 }
23604 Py_INCREF(Py_None); resultobj = Py_None;
23605 {
23606 if (temp2)
23607 delete arg2;
23608 }
23609 return resultobj;
23610 fail:
23611 {
23612 if (temp2)
23613 delete arg2;
23614 }
23615 return NULL;
23616 }
23617
23618
23619 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23620 PyObject *resultobj = NULL;
23621 wxPyApp *arg1 = (wxPyApp *) 0 ;
23622 wxString result;
23623 PyObject * obj0 = 0 ;
23624 char *kwnames[] = {
23625 (char *) "self", NULL
23626 };
23627
23628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23630 if (SWIG_arg_fail(1)) SWIG_fail;
23631 {
23632 PyThreadState* __tstate = wxPyBeginAllowThreads();
23633 result = ((wxPyApp const *)arg1)->GetClassName();
23634
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 {
23639 #if wxUSE_UNICODE
23640 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23641 #else
23642 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23643 #endif
23644 }
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23652 PyObject *resultobj = NULL;
23653 wxPyApp *arg1 = (wxPyApp *) 0 ;
23654 wxString *arg2 = 0 ;
23655 bool temp2 = false ;
23656 PyObject * obj0 = 0 ;
23657 PyObject * obj1 = 0 ;
23658 char *kwnames[] = {
23659 (char *) "self",(char *) "name", NULL
23660 };
23661
23662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23664 if (SWIG_arg_fail(1)) SWIG_fail;
23665 {
23666 arg2 = wxString_in_helper(obj1);
23667 if (arg2 == NULL) SWIG_fail;
23668 temp2 = true;
23669 }
23670 {
23671 PyThreadState* __tstate = wxPyBeginAllowThreads();
23672 (arg1)->SetClassName((wxString const &)*arg2);
23673
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 Py_INCREF(Py_None); resultobj = Py_None;
23678 {
23679 if (temp2)
23680 delete arg2;
23681 }
23682 return resultobj;
23683 fail:
23684 {
23685 if (temp2)
23686 delete arg2;
23687 }
23688 return NULL;
23689 }
23690
23691
23692 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23693 PyObject *resultobj = NULL;
23694 wxPyApp *arg1 = (wxPyApp *) 0 ;
23695 wxString *result;
23696 PyObject * obj0 = 0 ;
23697 char *kwnames[] = {
23698 (char *) "self", NULL
23699 };
23700
23701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23703 if (SWIG_arg_fail(1)) SWIG_fail;
23704 {
23705 PyThreadState* __tstate = wxPyBeginAllowThreads();
23706 {
23707 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23708 result = (wxString *) &_result_ref;
23709 }
23710
23711 wxPyEndAllowThreads(__tstate);
23712 if (PyErr_Occurred()) SWIG_fail;
23713 }
23714 {
23715 #if wxUSE_UNICODE
23716 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23717 #else
23718 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23719 #endif
23720 }
23721 return resultobj;
23722 fail:
23723 return NULL;
23724 }
23725
23726
23727 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj = NULL;
23729 wxPyApp *arg1 = (wxPyApp *) 0 ;
23730 wxString *arg2 = 0 ;
23731 bool temp2 = false ;
23732 PyObject * obj0 = 0 ;
23733 PyObject * obj1 = 0 ;
23734 char *kwnames[] = {
23735 (char *) "self",(char *) "name", NULL
23736 };
23737
23738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23740 if (SWIG_arg_fail(1)) SWIG_fail;
23741 {
23742 arg2 = wxString_in_helper(obj1);
23743 if (arg2 == NULL) SWIG_fail;
23744 temp2 = true;
23745 }
23746 {
23747 PyThreadState* __tstate = wxPyBeginAllowThreads();
23748 (arg1)->SetVendorName((wxString const &)*arg2);
23749
23750 wxPyEndAllowThreads(__tstate);
23751 if (PyErr_Occurred()) SWIG_fail;
23752 }
23753 Py_INCREF(Py_None); resultobj = Py_None;
23754 {
23755 if (temp2)
23756 delete arg2;
23757 }
23758 return resultobj;
23759 fail:
23760 {
23761 if (temp2)
23762 delete arg2;
23763 }
23764 return NULL;
23765 }
23766
23767
23768 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj = NULL;
23770 wxPyApp *arg1 = (wxPyApp *) 0 ;
23771 wxAppTraits *result;
23772 PyObject * obj0 = 0 ;
23773 char *kwnames[] = {
23774 (char *) "self", NULL
23775 };
23776
23777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23779 if (SWIG_arg_fail(1)) SWIG_fail;
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 result = (wxAppTraits *)(arg1)->GetTraits();
23783
23784 wxPyEndAllowThreads(__tstate);
23785 if (PyErr_Occurred()) SWIG_fail;
23786 }
23787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23788 return resultobj;
23789 fail:
23790 return NULL;
23791 }
23792
23793
23794 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23795 PyObject *resultobj = NULL;
23796 wxPyApp *arg1 = (wxPyApp *) 0 ;
23797 PyObject * obj0 = 0 ;
23798 char *kwnames[] = {
23799 (char *) "self", NULL
23800 };
23801
23802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23804 if (SWIG_arg_fail(1)) SWIG_fail;
23805 {
23806 PyThreadState* __tstate = wxPyBeginAllowThreads();
23807 (arg1)->ProcessPendingEvents();
23808
23809 wxPyEndAllowThreads(__tstate);
23810 if (PyErr_Occurred()) SWIG_fail;
23811 }
23812 Py_INCREF(Py_None); resultobj = Py_None;
23813 return resultobj;
23814 fail:
23815 return NULL;
23816 }
23817
23818
23819 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = NULL;
23821 wxPyApp *arg1 = (wxPyApp *) 0 ;
23822 bool arg2 = (bool) false ;
23823 bool result;
23824 PyObject * obj0 = 0 ;
23825 PyObject * obj1 = 0 ;
23826 char *kwnames[] = {
23827 (char *) "self",(char *) "onlyIfNeeded", NULL
23828 };
23829
23830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23832 if (SWIG_arg_fail(1)) SWIG_fail;
23833 if (obj1) {
23834 {
23835 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23836 if (SWIG_arg_fail(2)) SWIG_fail;
23837 }
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (bool)(arg1)->Yield(arg2);
23842
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 {
23847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23848 }
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23856 PyObject *resultobj = NULL;
23857 wxPyApp *arg1 = (wxPyApp *) 0 ;
23858 PyObject * obj0 = 0 ;
23859 char *kwnames[] = {
23860 (char *) "self", NULL
23861 };
23862
23863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23865 if (SWIG_arg_fail(1)) SWIG_fail;
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 (arg1)->WakeUpIdle();
23869
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 Py_INCREF(Py_None); resultobj = Py_None;
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23881 PyObject *resultobj = NULL;
23882 bool result;
23883 char *kwnames[] = {
23884 NULL
23885 };
23886
23887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23888 {
23889 PyThreadState* __tstate = wxPyBeginAllowThreads();
23890 result = (bool)wxPyApp::IsMainLoopRunning();
23891
23892 wxPyEndAllowThreads(__tstate);
23893 if (PyErr_Occurred()) SWIG_fail;
23894 }
23895 {
23896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23897 }
23898 return resultobj;
23899 fail:
23900 return NULL;
23901 }
23902
23903
23904 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23905 PyObject *resultobj = NULL;
23906 wxPyApp *arg1 = (wxPyApp *) 0 ;
23907 int result;
23908 PyObject * obj0 = 0 ;
23909 char *kwnames[] = {
23910 (char *) "self", NULL
23911 };
23912
23913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23915 if (SWIG_arg_fail(1)) SWIG_fail;
23916 {
23917 PyThreadState* __tstate = wxPyBeginAllowThreads();
23918 result = (int)(arg1)->MainLoop();
23919
23920 wxPyEndAllowThreads(__tstate);
23921 if (PyErr_Occurred()) SWIG_fail;
23922 }
23923 {
23924 resultobj = SWIG_From_int(static_cast<int >(result));
23925 }
23926 return resultobj;
23927 fail:
23928 return NULL;
23929 }
23930
23931
23932 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23933 PyObject *resultobj = NULL;
23934 wxPyApp *arg1 = (wxPyApp *) 0 ;
23935 PyObject * obj0 = 0 ;
23936 char *kwnames[] = {
23937 (char *) "self", NULL
23938 };
23939
23940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23942 if (SWIG_arg_fail(1)) SWIG_fail;
23943 {
23944 PyThreadState* __tstate = wxPyBeginAllowThreads();
23945 (arg1)->Exit();
23946
23947 wxPyEndAllowThreads(__tstate);
23948 if (PyErr_Occurred()) SWIG_fail;
23949 }
23950 Py_INCREF(Py_None); resultobj = Py_None;
23951 return resultobj;
23952 fail:
23953 return NULL;
23954 }
23955
23956
23957 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23958 PyObject *resultobj = NULL;
23959 wxPyApp *arg1 = (wxPyApp *) 0 ;
23960 PyObject * obj0 = 0 ;
23961 char *kwnames[] = {
23962 (char *) "self", NULL
23963 };
23964
23965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23967 if (SWIG_arg_fail(1)) SWIG_fail;
23968 {
23969 PyThreadState* __tstate = wxPyBeginAllowThreads();
23970 (arg1)->ExitMainLoop();
23971
23972 wxPyEndAllowThreads(__tstate);
23973 if (PyErr_Occurred()) SWIG_fail;
23974 }
23975 Py_INCREF(Py_None); resultobj = Py_None;
23976 return resultobj;
23977 fail:
23978 return NULL;
23979 }
23980
23981
23982 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23983 PyObject *resultobj = NULL;
23984 wxPyApp *arg1 = (wxPyApp *) 0 ;
23985 bool result;
23986 PyObject * obj0 = 0 ;
23987 char *kwnames[] = {
23988 (char *) "self", NULL
23989 };
23990
23991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23993 if (SWIG_arg_fail(1)) SWIG_fail;
23994 {
23995 PyThreadState* __tstate = wxPyBeginAllowThreads();
23996 result = (bool)(arg1)->Pending();
23997
23998 wxPyEndAllowThreads(__tstate);
23999 if (PyErr_Occurred()) SWIG_fail;
24000 }
24001 {
24002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24003 }
24004 return resultobj;
24005 fail:
24006 return NULL;
24007 }
24008
24009
24010 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24011 PyObject *resultobj = NULL;
24012 wxPyApp *arg1 = (wxPyApp *) 0 ;
24013 bool result;
24014 PyObject * obj0 = 0 ;
24015 char *kwnames[] = {
24016 (char *) "self", NULL
24017 };
24018
24019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
24020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24021 if (SWIG_arg_fail(1)) SWIG_fail;
24022 {
24023 PyThreadState* __tstate = wxPyBeginAllowThreads();
24024 result = (bool)(arg1)->Dispatch();
24025
24026 wxPyEndAllowThreads(__tstate);
24027 if (PyErr_Occurred()) SWIG_fail;
24028 }
24029 {
24030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24031 }
24032 return resultobj;
24033 fail:
24034 return NULL;
24035 }
24036
24037
24038 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24039 PyObject *resultobj = NULL;
24040 wxPyApp *arg1 = (wxPyApp *) 0 ;
24041 bool result;
24042 PyObject * obj0 = 0 ;
24043 char *kwnames[] = {
24044 (char *) "self", NULL
24045 };
24046
24047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
24048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24049 if (SWIG_arg_fail(1)) SWIG_fail;
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (bool)(arg1)->ProcessIdle();
24053
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 {
24058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24059 }
24060 return resultobj;
24061 fail:
24062 return NULL;
24063 }
24064
24065
24066 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
24067 PyObject *resultobj = NULL;
24068 wxPyApp *arg1 = (wxPyApp *) 0 ;
24069 wxWindow *arg2 = (wxWindow *) 0 ;
24070 wxIdleEvent *arg3 = 0 ;
24071 bool result;
24072 PyObject * obj0 = 0 ;
24073 PyObject * obj1 = 0 ;
24074 PyObject * obj2 = 0 ;
24075 char *kwnames[] = {
24076 (char *) "self",(char *) "win",(char *) "event", NULL
24077 };
24078
24079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
24080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24081 if (SWIG_arg_fail(1)) SWIG_fail;
24082 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24083 if (SWIG_arg_fail(2)) SWIG_fail;
24084 {
24085 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24086 if (SWIG_arg_fail(3)) SWIG_fail;
24087 if (arg3 == NULL) {
24088 SWIG_null_ref("wxIdleEvent");
24089 }
24090 if (SWIG_arg_fail(3)) SWIG_fail;
24091 }
24092 {
24093 PyThreadState* __tstate = wxPyBeginAllowThreads();
24094 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24095
24096 wxPyEndAllowThreads(__tstate);
24097 if (PyErr_Occurred()) SWIG_fail;
24098 }
24099 {
24100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24101 }
24102 return resultobj;
24103 fail:
24104 return NULL;
24105 }
24106
24107
24108 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24109 PyObject *resultobj = NULL;
24110 wxPyApp *arg1 = (wxPyApp *) 0 ;
24111 bool result;
24112 PyObject * obj0 = 0 ;
24113 char *kwnames[] = {
24114 (char *) "self", NULL
24115 };
24116
24117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24119 if (SWIG_arg_fail(1)) SWIG_fail;
24120 {
24121 PyThreadState* __tstate = wxPyBeginAllowThreads();
24122 result = (bool)((wxPyApp const *)arg1)->IsActive();
24123
24124 wxPyEndAllowThreads(__tstate);
24125 if (PyErr_Occurred()) SWIG_fail;
24126 }
24127 {
24128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24129 }
24130 return resultobj;
24131 fail:
24132 return NULL;
24133 }
24134
24135
24136 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24137 PyObject *resultobj = NULL;
24138 wxPyApp *arg1 = (wxPyApp *) 0 ;
24139 wxWindow *arg2 = (wxWindow *) 0 ;
24140 PyObject * obj0 = 0 ;
24141 PyObject * obj1 = 0 ;
24142 char *kwnames[] = {
24143 (char *) "self",(char *) "win", NULL
24144 };
24145
24146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24148 if (SWIG_arg_fail(1)) SWIG_fail;
24149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24150 if (SWIG_arg_fail(2)) SWIG_fail;
24151 {
24152 PyThreadState* __tstate = wxPyBeginAllowThreads();
24153 (arg1)->SetTopWindow(arg2);
24154
24155 wxPyEndAllowThreads(__tstate);
24156 if (PyErr_Occurred()) SWIG_fail;
24157 }
24158 Py_INCREF(Py_None); resultobj = Py_None;
24159 return resultobj;
24160 fail:
24161 return NULL;
24162 }
24163
24164
24165 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24166 PyObject *resultobj = NULL;
24167 wxPyApp *arg1 = (wxPyApp *) 0 ;
24168 wxWindow *result;
24169 PyObject * obj0 = 0 ;
24170 char *kwnames[] = {
24171 (char *) "self", NULL
24172 };
24173
24174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24176 if (SWIG_arg_fail(1)) SWIG_fail;
24177 {
24178 PyThreadState* __tstate = wxPyBeginAllowThreads();
24179 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24180
24181 wxPyEndAllowThreads(__tstate);
24182 if (PyErr_Occurred()) SWIG_fail;
24183 }
24184 {
24185 resultobj = wxPyMake_wxObject(result, (bool)0);
24186 }
24187 return resultobj;
24188 fail:
24189 return NULL;
24190 }
24191
24192
24193 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24194 PyObject *resultobj = NULL;
24195 wxPyApp *arg1 = (wxPyApp *) 0 ;
24196 bool arg2 ;
24197 PyObject * obj0 = 0 ;
24198 PyObject * obj1 = 0 ;
24199 char *kwnames[] = {
24200 (char *) "self",(char *) "flag", NULL
24201 };
24202
24203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24205 if (SWIG_arg_fail(1)) SWIG_fail;
24206 {
24207 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24208 if (SWIG_arg_fail(2)) SWIG_fail;
24209 }
24210 {
24211 PyThreadState* __tstate = wxPyBeginAllowThreads();
24212 (arg1)->SetExitOnFrameDelete(arg2);
24213
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 Py_INCREF(Py_None); resultobj = Py_None;
24218 return resultobj;
24219 fail:
24220 return NULL;
24221 }
24222
24223
24224 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24225 PyObject *resultobj = NULL;
24226 wxPyApp *arg1 = (wxPyApp *) 0 ;
24227 bool result;
24228 PyObject * obj0 = 0 ;
24229 char *kwnames[] = {
24230 (char *) "self", NULL
24231 };
24232
24233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24235 if (SWIG_arg_fail(1)) SWIG_fail;
24236 {
24237 PyThreadState* __tstate = wxPyBeginAllowThreads();
24238 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24239
24240 wxPyEndAllowThreads(__tstate);
24241 if (PyErr_Occurred()) SWIG_fail;
24242 }
24243 {
24244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24245 }
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24253 PyObject *resultobj = NULL;
24254 wxPyApp *arg1 = (wxPyApp *) 0 ;
24255 bool arg2 ;
24256 PyObject * obj0 = 0 ;
24257 PyObject * obj1 = 0 ;
24258 char *kwnames[] = {
24259 (char *) "self",(char *) "flag", NULL
24260 };
24261
24262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24264 if (SWIG_arg_fail(1)) SWIG_fail;
24265 {
24266 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24267 if (SWIG_arg_fail(2)) SWIG_fail;
24268 }
24269 {
24270 PyThreadState* __tstate = wxPyBeginAllowThreads();
24271 (arg1)->SetUseBestVisual(arg2);
24272
24273 wxPyEndAllowThreads(__tstate);
24274 if (PyErr_Occurred()) SWIG_fail;
24275 }
24276 Py_INCREF(Py_None); resultobj = Py_None;
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24284 PyObject *resultobj = NULL;
24285 wxPyApp *arg1 = (wxPyApp *) 0 ;
24286 bool result;
24287 PyObject * obj0 = 0 ;
24288 char *kwnames[] = {
24289 (char *) "self", NULL
24290 };
24291
24292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24294 if (SWIG_arg_fail(1)) SWIG_fail;
24295 {
24296 PyThreadState* __tstate = wxPyBeginAllowThreads();
24297 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24298
24299 wxPyEndAllowThreads(__tstate);
24300 if (PyErr_Occurred()) SWIG_fail;
24301 }
24302 {
24303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24304 }
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj = NULL;
24313 wxPyApp *arg1 = (wxPyApp *) 0 ;
24314 int arg2 ;
24315 PyObject * obj0 = 0 ;
24316 PyObject * obj1 = 0 ;
24317 char *kwnames[] = {
24318 (char *) "self",(char *) "mode", NULL
24319 };
24320
24321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24323 if (SWIG_arg_fail(1)) SWIG_fail;
24324 {
24325 arg2 = static_cast<int >(SWIG_As_int(obj1));
24326 if (SWIG_arg_fail(2)) SWIG_fail;
24327 }
24328 {
24329 PyThreadState* __tstate = wxPyBeginAllowThreads();
24330 (arg1)->SetPrintMode(arg2);
24331
24332 wxPyEndAllowThreads(__tstate);
24333 if (PyErr_Occurred()) SWIG_fail;
24334 }
24335 Py_INCREF(Py_None); resultobj = Py_None;
24336 return resultobj;
24337 fail:
24338 return NULL;
24339 }
24340
24341
24342 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24343 PyObject *resultobj = NULL;
24344 wxPyApp *arg1 = (wxPyApp *) 0 ;
24345 int result;
24346 PyObject * obj0 = 0 ;
24347 char *kwnames[] = {
24348 (char *) "self", NULL
24349 };
24350
24351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24353 if (SWIG_arg_fail(1)) SWIG_fail;
24354 {
24355 PyThreadState* __tstate = wxPyBeginAllowThreads();
24356 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24357
24358 wxPyEndAllowThreads(__tstate);
24359 if (PyErr_Occurred()) SWIG_fail;
24360 }
24361 {
24362 resultobj = SWIG_From_int(static_cast<int >(result));
24363 }
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24371 PyObject *resultobj = NULL;
24372 wxPyApp *arg1 = (wxPyApp *) 0 ;
24373 int arg2 ;
24374 PyObject * obj0 = 0 ;
24375 PyObject * obj1 = 0 ;
24376 char *kwnames[] = {
24377 (char *) "self",(char *) "mode", NULL
24378 };
24379
24380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24382 if (SWIG_arg_fail(1)) SWIG_fail;
24383 {
24384 arg2 = static_cast<int >(SWIG_As_int(obj1));
24385 if (SWIG_arg_fail(2)) SWIG_fail;
24386 }
24387 {
24388 PyThreadState* __tstate = wxPyBeginAllowThreads();
24389 (arg1)->SetAssertMode(arg2);
24390
24391 wxPyEndAllowThreads(__tstate);
24392 if (PyErr_Occurred()) SWIG_fail;
24393 }
24394 Py_INCREF(Py_None); resultobj = Py_None;
24395 return resultobj;
24396 fail:
24397 return NULL;
24398 }
24399
24400
24401 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24402 PyObject *resultobj = NULL;
24403 wxPyApp *arg1 = (wxPyApp *) 0 ;
24404 int result;
24405 PyObject * obj0 = 0 ;
24406 char *kwnames[] = {
24407 (char *) "self", NULL
24408 };
24409
24410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24412 if (SWIG_arg_fail(1)) SWIG_fail;
24413 {
24414 PyThreadState* __tstate = wxPyBeginAllowThreads();
24415 result = (int)(arg1)->GetAssertMode();
24416
24417 wxPyEndAllowThreads(__tstate);
24418 if (PyErr_Occurred()) SWIG_fail;
24419 }
24420 {
24421 resultobj = SWIG_From_int(static_cast<int >(result));
24422 }
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24430 PyObject *resultobj = NULL;
24431 bool result;
24432 char *kwnames[] = {
24433 NULL
24434 };
24435
24436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24437 {
24438 PyThreadState* __tstate = wxPyBeginAllowThreads();
24439 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24440
24441 wxPyEndAllowThreads(__tstate);
24442 if (PyErr_Occurred()) SWIG_fail;
24443 }
24444 {
24445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24446 }
24447 return resultobj;
24448 fail:
24449 return NULL;
24450 }
24451
24452
24453 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24454 PyObject *resultobj = NULL;
24455 long result;
24456 char *kwnames[] = {
24457 NULL
24458 };
24459
24460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24461 {
24462 PyThreadState* __tstate = wxPyBeginAllowThreads();
24463 result = (long)wxPyApp::GetMacAboutMenuItemId();
24464
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 {
24469 resultobj = SWIG_From_long(static_cast<long >(result));
24470 }
24471 return resultobj;
24472 fail:
24473 return NULL;
24474 }
24475
24476
24477 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24478 PyObject *resultobj = NULL;
24479 long result;
24480 char *kwnames[] = {
24481 NULL
24482 };
24483
24484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24485 {
24486 PyThreadState* __tstate = wxPyBeginAllowThreads();
24487 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24488
24489 wxPyEndAllowThreads(__tstate);
24490 if (PyErr_Occurred()) SWIG_fail;
24491 }
24492 {
24493 resultobj = SWIG_From_long(static_cast<long >(result));
24494 }
24495 return resultobj;
24496 fail:
24497 return NULL;
24498 }
24499
24500
24501 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24502 PyObject *resultobj = NULL;
24503 long result;
24504 char *kwnames[] = {
24505 NULL
24506 };
24507
24508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24509 {
24510 PyThreadState* __tstate = wxPyBeginAllowThreads();
24511 result = (long)wxPyApp::GetMacExitMenuItemId();
24512
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 {
24517 resultobj = SWIG_From_long(static_cast<long >(result));
24518 }
24519 return resultobj;
24520 fail:
24521 return NULL;
24522 }
24523
24524
24525 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24526 PyObject *resultobj = NULL;
24527 wxString result;
24528 char *kwnames[] = {
24529 NULL
24530 };
24531
24532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24533 {
24534 PyThreadState* __tstate = wxPyBeginAllowThreads();
24535 result = wxPyApp::GetMacHelpMenuTitleName();
24536
24537 wxPyEndAllowThreads(__tstate);
24538 if (PyErr_Occurred()) SWIG_fail;
24539 }
24540 {
24541 #if wxUSE_UNICODE
24542 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24543 #else
24544 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24545 #endif
24546 }
24547 return resultobj;
24548 fail:
24549 return NULL;
24550 }
24551
24552
24553 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24554 PyObject *resultobj = NULL;
24555 bool arg1 ;
24556 PyObject * obj0 = 0 ;
24557 char *kwnames[] = {
24558 (char *) "val", NULL
24559 };
24560
24561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24562 {
24563 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24564 if (SWIG_arg_fail(1)) SWIG_fail;
24565 }
24566 {
24567 PyThreadState* __tstate = wxPyBeginAllowThreads();
24568 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24569
24570 wxPyEndAllowThreads(__tstate);
24571 if (PyErr_Occurred()) SWIG_fail;
24572 }
24573 Py_INCREF(Py_None); resultobj = Py_None;
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24581 PyObject *resultobj = NULL;
24582 long arg1 ;
24583 PyObject * obj0 = 0 ;
24584 char *kwnames[] = {
24585 (char *) "val", NULL
24586 };
24587
24588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24589 {
24590 arg1 = static_cast<long >(SWIG_As_long(obj0));
24591 if (SWIG_arg_fail(1)) SWIG_fail;
24592 }
24593 {
24594 PyThreadState* __tstate = wxPyBeginAllowThreads();
24595 wxPyApp::SetMacAboutMenuItemId(arg1);
24596
24597 wxPyEndAllowThreads(__tstate);
24598 if (PyErr_Occurred()) SWIG_fail;
24599 }
24600 Py_INCREF(Py_None); resultobj = Py_None;
24601 return resultobj;
24602 fail:
24603 return NULL;
24604 }
24605
24606
24607 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24608 PyObject *resultobj = NULL;
24609 long arg1 ;
24610 PyObject * obj0 = 0 ;
24611 char *kwnames[] = {
24612 (char *) "val", NULL
24613 };
24614
24615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24616 {
24617 arg1 = static_cast<long >(SWIG_As_long(obj0));
24618 if (SWIG_arg_fail(1)) SWIG_fail;
24619 }
24620 {
24621 PyThreadState* __tstate = wxPyBeginAllowThreads();
24622 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24623
24624 wxPyEndAllowThreads(__tstate);
24625 if (PyErr_Occurred()) SWIG_fail;
24626 }
24627 Py_INCREF(Py_None); resultobj = Py_None;
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj = NULL;
24636 long arg1 ;
24637 PyObject * obj0 = 0 ;
24638 char *kwnames[] = {
24639 (char *) "val", NULL
24640 };
24641
24642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24643 {
24644 arg1 = static_cast<long >(SWIG_As_long(obj0));
24645 if (SWIG_arg_fail(1)) SWIG_fail;
24646 }
24647 {
24648 PyThreadState* __tstate = wxPyBeginAllowThreads();
24649 wxPyApp::SetMacExitMenuItemId(arg1);
24650
24651 wxPyEndAllowThreads(__tstate);
24652 if (PyErr_Occurred()) SWIG_fail;
24653 }
24654 Py_INCREF(Py_None); resultobj = Py_None;
24655 return resultobj;
24656 fail:
24657 return NULL;
24658 }
24659
24660
24661 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24662 PyObject *resultobj = NULL;
24663 wxString *arg1 = 0 ;
24664 bool temp1 = false ;
24665 PyObject * obj0 = 0 ;
24666 char *kwnames[] = {
24667 (char *) "val", NULL
24668 };
24669
24670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24671 {
24672 arg1 = wxString_in_helper(obj0);
24673 if (arg1 == NULL) SWIG_fail;
24674 temp1 = true;
24675 }
24676 {
24677 PyThreadState* __tstate = wxPyBeginAllowThreads();
24678 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24679
24680 wxPyEndAllowThreads(__tstate);
24681 if (PyErr_Occurred()) SWIG_fail;
24682 }
24683 Py_INCREF(Py_None); resultobj = Py_None;
24684 {
24685 if (temp1)
24686 delete arg1;
24687 }
24688 return resultobj;
24689 fail:
24690 {
24691 if (temp1)
24692 delete arg1;
24693 }
24694 return NULL;
24695 }
24696
24697
24698 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24699 PyObject *resultobj = NULL;
24700 wxPyApp *arg1 = (wxPyApp *) 0 ;
24701 PyObject * obj0 = 0 ;
24702 char *kwnames[] = {
24703 (char *) "self", NULL
24704 };
24705
24706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24708 if (SWIG_arg_fail(1)) SWIG_fail;
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 (arg1)->_BootstrapApp();
24712
24713 wxPyEndAllowThreads(__tstate);
24714 if (PyErr_Occurred()) SWIG_fail;
24715 }
24716 Py_INCREF(Py_None); resultobj = Py_None;
24717 return resultobj;
24718 fail:
24719 return NULL;
24720 }
24721
24722
24723 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24724 PyObject *resultobj = NULL;
24725 int result;
24726 char *kwnames[] = {
24727 NULL
24728 };
24729
24730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24731 {
24732 PyThreadState* __tstate = wxPyBeginAllowThreads();
24733 result = (int)wxPyApp::GetComCtl32Version();
24734
24735 wxPyEndAllowThreads(__tstate);
24736 if (PyErr_Occurred()) SWIG_fail;
24737 }
24738 {
24739 resultobj = SWIG_From_int(static_cast<int >(result));
24740 }
24741 return resultobj;
24742 fail:
24743 return NULL;
24744 }
24745
24746
24747 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24748 PyObject *obj;
24749 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24750 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24751 Py_INCREF(obj);
24752 return Py_BuildValue((char *)"");
24753 }
24754 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24755 PyObject *resultobj = NULL;
24756 char *kwnames[] = {
24757 NULL
24758 };
24759
24760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24761 {
24762 PyThreadState* __tstate = wxPyBeginAllowThreads();
24763 wxExit();
24764
24765 wxPyEndAllowThreads(__tstate);
24766 if (PyErr_Occurred()) SWIG_fail;
24767 }
24768 Py_INCREF(Py_None); resultobj = Py_None;
24769 return resultobj;
24770 fail:
24771 return NULL;
24772 }
24773
24774
24775 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24776 PyObject *resultobj = NULL;
24777 bool result;
24778 char *kwnames[] = {
24779 NULL
24780 };
24781
24782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24783 {
24784 PyThreadState* __tstate = wxPyBeginAllowThreads();
24785 result = (bool)wxYield();
24786
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 {
24791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24792 }
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24800 PyObject *resultobj = NULL;
24801 bool result;
24802 char *kwnames[] = {
24803 NULL
24804 };
24805
24806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 result = (bool)wxYieldIfNeeded();
24810
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 {
24815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24816 }
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24824 PyObject *resultobj = NULL;
24825 wxWindow *arg1 = (wxWindow *) NULL ;
24826 bool arg2 = (bool) false ;
24827 bool result;
24828 PyObject * obj0 = 0 ;
24829 PyObject * obj1 = 0 ;
24830 char *kwnames[] = {
24831 (char *) "win",(char *) "onlyIfNeeded", NULL
24832 };
24833
24834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24835 if (obj0) {
24836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24837 if (SWIG_arg_fail(1)) SWIG_fail;
24838 }
24839 if (obj1) {
24840 {
24841 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24842 if (SWIG_arg_fail(2)) SWIG_fail;
24843 }
24844 }
24845 {
24846 PyThreadState* __tstate = wxPyBeginAllowThreads();
24847 result = (bool)wxSafeYield(arg1,arg2);
24848
24849 wxPyEndAllowThreads(__tstate);
24850 if (PyErr_Occurred()) SWIG_fail;
24851 }
24852 {
24853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24854 }
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24862 PyObject *resultobj = NULL;
24863 char *kwnames[] = {
24864 NULL
24865 };
24866
24867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 wxWakeUpIdle();
24871
24872 wxPyEndAllowThreads(__tstate);
24873 if (PyErr_Occurred()) SWIG_fail;
24874 }
24875 Py_INCREF(Py_None); resultobj = Py_None;
24876 return resultobj;
24877 fail:
24878 return NULL;
24879 }
24880
24881
24882 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24883 PyObject *resultobj = NULL;
24884 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24885 wxEvent *arg2 = 0 ;
24886 PyObject * obj0 = 0 ;
24887 PyObject * obj1 = 0 ;
24888 char *kwnames[] = {
24889 (char *) "dest",(char *) "event", NULL
24890 };
24891
24892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24894 if (SWIG_arg_fail(1)) SWIG_fail;
24895 {
24896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24897 if (SWIG_arg_fail(2)) SWIG_fail;
24898 if (arg2 == NULL) {
24899 SWIG_null_ref("wxEvent");
24900 }
24901 if (SWIG_arg_fail(2)) SWIG_fail;
24902 }
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 wxPostEvent(arg1,*arg2);
24906
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 Py_INCREF(Py_None); resultobj = Py_None;
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24918 PyObject *resultobj = NULL;
24919 char *kwnames[] = {
24920 NULL
24921 };
24922
24923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24924 {
24925 PyThreadState* __tstate = wxPyBeginAllowThreads();
24926 wxApp_CleanUp();
24927
24928 wxPyEndAllowThreads(__tstate);
24929 if (PyErr_Occurred()) SWIG_fail;
24930 }
24931 Py_INCREF(Py_None); resultobj = Py_None;
24932 return resultobj;
24933 fail:
24934 return NULL;
24935 }
24936
24937
24938 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24939 PyObject *resultobj = NULL;
24940 wxPyApp *result;
24941 char *kwnames[] = {
24942 NULL
24943 };
24944
24945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24946 {
24947 PyThreadState* __tstate = wxPyBeginAllowThreads();
24948 result = (wxPyApp *)wxPyGetApp();
24949
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 {
24954 resultobj = wxPyMake_wxObject(result, 0);
24955 }
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24963 PyObject *resultobj = NULL;
24964 char *arg1 = (char *) 0 ;
24965 PyObject * obj0 = 0 ;
24966 char *kwnames[] = {
24967 (char *) "encoding", NULL
24968 };
24969
24970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24971 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24972 SWIG_arg_fail(1);SWIG_fail;
24973 }
24974 {
24975 PyThreadState* __tstate = wxPyBeginAllowThreads();
24976 wxSetDefaultPyEncoding((char const *)arg1);
24977
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 Py_INCREF(Py_None); resultobj = Py_None;
24982 return resultobj;
24983 fail:
24984 return NULL;
24985 }
24986
24987
24988 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24989 PyObject *resultobj = NULL;
24990 char *result;
24991 char *kwnames[] = {
24992 NULL
24993 };
24994
24995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (char *)wxGetDefaultPyEncoding();
24999
25000 wxPyEndAllowThreads(__tstate);
25001 if (PyErr_Occurred()) SWIG_fail;
25002 }
25003 resultobj = SWIG_FromCharPtr(result);
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
25011 PyObject *resultobj = NULL;
25012 wxEventLoop *result;
25013 char *kwnames[] = {
25014 NULL
25015 };
25016
25017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 result = (wxEventLoop *)new wxEventLoop();
25021
25022 wxPyEndAllowThreads(__tstate);
25023 if (PyErr_Occurred()) SWIG_fail;
25024 }
25025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
25026 return resultobj;
25027 fail:
25028 return NULL;
25029 }
25030
25031
25032 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
25033 PyObject *resultobj = NULL;
25034 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25035 PyObject * obj0 = 0 ;
25036 char *kwnames[] = {
25037 (char *) "self", NULL
25038 };
25039
25040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
25041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25042 if (SWIG_arg_fail(1)) SWIG_fail;
25043 {
25044 PyThreadState* __tstate = wxPyBeginAllowThreads();
25045 delete arg1;
25046
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 Py_INCREF(Py_None); resultobj = Py_None;
25051 return resultobj;
25052 fail:
25053 return NULL;
25054 }
25055
25056
25057 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
25058 PyObject *resultobj = NULL;
25059 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25060 int result;
25061 PyObject * obj0 = 0 ;
25062 char *kwnames[] = {
25063 (char *) "self", NULL
25064 };
25065
25066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
25067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25068 if (SWIG_arg_fail(1)) SWIG_fail;
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 result = (int)(arg1)->Run();
25072
25073 wxPyEndAllowThreads(__tstate);
25074 if (PyErr_Occurred()) SWIG_fail;
25075 }
25076 {
25077 resultobj = SWIG_From_int(static_cast<int >(result));
25078 }
25079 return resultobj;
25080 fail:
25081 return NULL;
25082 }
25083
25084
25085 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25086 PyObject *resultobj = NULL;
25087 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25088 int arg2 = (int) 0 ;
25089 PyObject * obj0 = 0 ;
25090 PyObject * obj1 = 0 ;
25091 char *kwnames[] = {
25092 (char *) "self",(char *) "rc", NULL
25093 };
25094
25095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25097 if (SWIG_arg_fail(1)) SWIG_fail;
25098 if (obj1) {
25099 {
25100 arg2 = static_cast<int >(SWIG_As_int(obj1));
25101 if (SWIG_arg_fail(2)) SWIG_fail;
25102 }
25103 }
25104 {
25105 PyThreadState* __tstate = wxPyBeginAllowThreads();
25106 (arg1)->Exit(arg2);
25107
25108 wxPyEndAllowThreads(__tstate);
25109 if (PyErr_Occurred()) SWIG_fail;
25110 }
25111 Py_INCREF(Py_None); resultobj = Py_None;
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25119 PyObject *resultobj = NULL;
25120 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25121 bool result;
25122 PyObject * obj0 = 0 ;
25123 char *kwnames[] = {
25124 (char *) "self", NULL
25125 };
25126
25127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25129 if (SWIG_arg_fail(1)) SWIG_fail;
25130 {
25131 PyThreadState* __tstate = wxPyBeginAllowThreads();
25132 result = (bool)((wxEventLoop const *)arg1)->Pending();
25133
25134 wxPyEndAllowThreads(__tstate);
25135 if (PyErr_Occurred()) SWIG_fail;
25136 }
25137 {
25138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25139 }
25140 return resultobj;
25141 fail:
25142 return NULL;
25143 }
25144
25145
25146 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25147 PyObject *resultobj = NULL;
25148 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25149 bool result;
25150 PyObject * obj0 = 0 ;
25151 char *kwnames[] = {
25152 (char *) "self", NULL
25153 };
25154
25155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
25156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25157 if (SWIG_arg_fail(1)) SWIG_fail;
25158 {
25159 PyThreadState* __tstate = wxPyBeginAllowThreads();
25160 result = (bool)(arg1)->Dispatch();
25161
25162 wxPyEndAllowThreads(__tstate);
25163 if (PyErr_Occurred()) SWIG_fail;
25164 }
25165 {
25166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25167 }
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25175 PyObject *resultobj = NULL;
25176 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25177 bool result;
25178 PyObject * obj0 = 0 ;
25179 char *kwnames[] = {
25180 (char *) "self", NULL
25181 };
25182
25183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25185 if (SWIG_arg_fail(1)) SWIG_fail;
25186 {
25187 PyThreadState* __tstate = wxPyBeginAllowThreads();
25188 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25189
25190 wxPyEndAllowThreads(__tstate);
25191 if (PyErr_Occurred()) SWIG_fail;
25192 }
25193 {
25194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25195 }
25196 return resultobj;
25197 fail:
25198 return NULL;
25199 }
25200
25201
25202 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25203 PyObject *resultobj = NULL;
25204 wxEventLoop *result;
25205 char *kwnames[] = {
25206 NULL
25207 };
25208
25209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = (wxEventLoop *)wxEventLoop::GetActive();
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj = NULL;
25226 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25227 PyObject * obj0 = 0 ;
25228 char *kwnames[] = {
25229 (char *) "loop", NULL
25230 };
25231
25232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25234 if (SWIG_arg_fail(1)) SWIG_fail;
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 wxEventLoop::SetActive(arg1);
25238
25239 wxPyEndAllowThreads(__tstate);
25240 if (PyErr_Occurred()) SWIG_fail;
25241 }
25242 Py_INCREF(Py_None); resultobj = Py_None;
25243 return resultobj;
25244 fail:
25245 return NULL;
25246 }
25247
25248
25249 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25250 PyObject *obj;
25251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25252 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25253 Py_INCREF(obj);
25254 return Py_BuildValue((char *)"");
25255 }
25256 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj = NULL;
25258 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25259 wxEventLoopActivator *result;
25260 PyObject * obj0 = 0 ;
25261 char *kwnames[] = {
25262 (char *) "evtLoop", NULL
25263 };
25264
25265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25267 if (SWIG_arg_fail(1)) SWIG_fail;
25268 {
25269 PyThreadState* __tstate = wxPyBeginAllowThreads();
25270 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25271
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25276 return resultobj;
25277 fail:
25278 return NULL;
25279 }
25280
25281
25282 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25283 PyObject *resultobj = NULL;
25284 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25285 PyObject * obj0 = 0 ;
25286 char *kwnames[] = {
25287 (char *) "self", NULL
25288 };
25289
25290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25292 if (SWIG_arg_fail(1)) SWIG_fail;
25293 {
25294 PyThreadState* __tstate = wxPyBeginAllowThreads();
25295 delete arg1;
25296
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 Py_INCREF(Py_None); resultobj = Py_None;
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25308 PyObject *obj;
25309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25310 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25311 Py_INCREF(obj);
25312 return Py_BuildValue((char *)"");
25313 }
25314 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj = NULL;
25316 int arg1 = (int) 0 ;
25317 int arg2 = (int) 0 ;
25318 int arg3 = (int) 0 ;
25319 wxAcceleratorEntry *result;
25320 PyObject * obj0 = 0 ;
25321 PyObject * obj1 = 0 ;
25322 PyObject * obj2 = 0 ;
25323 char *kwnames[] = {
25324 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25325 };
25326
25327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25328 if (obj0) {
25329 {
25330 arg1 = static_cast<int >(SWIG_As_int(obj0));
25331 if (SWIG_arg_fail(1)) SWIG_fail;
25332 }
25333 }
25334 if (obj1) {
25335 {
25336 arg2 = static_cast<int >(SWIG_As_int(obj1));
25337 if (SWIG_arg_fail(2)) SWIG_fail;
25338 }
25339 }
25340 if (obj2) {
25341 {
25342 arg3 = static_cast<int >(SWIG_As_int(obj2));
25343 if (SWIG_arg_fail(3)) SWIG_fail;
25344 }
25345 }
25346 {
25347 PyThreadState* __tstate = wxPyBeginAllowThreads();
25348 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25349
25350 wxPyEndAllowThreads(__tstate);
25351 if (PyErr_Occurred()) SWIG_fail;
25352 }
25353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25354 return resultobj;
25355 fail:
25356 return NULL;
25357 }
25358
25359
25360 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25361 PyObject *resultobj = NULL;
25362 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25363 PyObject * obj0 = 0 ;
25364 char *kwnames[] = {
25365 (char *) "self", NULL
25366 };
25367
25368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25370 if (SWIG_arg_fail(1)) SWIG_fail;
25371 {
25372 PyThreadState* __tstate = wxPyBeginAllowThreads();
25373 delete arg1;
25374
25375 wxPyEndAllowThreads(__tstate);
25376 if (PyErr_Occurred()) SWIG_fail;
25377 }
25378 Py_INCREF(Py_None); resultobj = Py_None;
25379 return resultobj;
25380 fail:
25381 return NULL;
25382 }
25383
25384
25385 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25386 PyObject *resultobj = NULL;
25387 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25388 int arg2 ;
25389 int arg3 ;
25390 int arg4 ;
25391 PyObject * obj0 = 0 ;
25392 PyObject * obj1 = 0 ;
25393 PyObject * obj2 = 0 ;
25394 PyObject * obj3 = 0 ;
25395 char *kwnames[] = {
25396 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25397 };
25398
25399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25401 if (SWIG_arg_fail(1)) SWIG_fail;
25402 {
25403 arg2 = static_cast<int >(SWIG_As_int(obj1));
25404 if (SWIG_arg_fail(2)) SWIG_fail;
25405 }
25406 {
25407 arg3 = static_cast<int >(SWIG_As_int(obj2));
25408 if (SWIG_arg_fail(3)) SWIG_fail;
25409 }
25410 {
25411 arg4 = static_cast<int >(SWIG_As_int(obj3));
25412 if (SWIG_arg_fail(4)) SWIG_fail;
25413 }
25414 {
25415 PyThreadState* __tstate = wxPyBeginAllowThreads();
25416 (arg1)->Set(arg2,arg3,arg4);
25417
25418 wxPyEndAllowThreads(__tstate);
25419 if (PyErr_Occurred()) SWIG_fail;
25420 }
25421 Py_INCREF(Py_None); resultobj = Py_None;
25422 return resultobj;
25423 fail:
25424 return NULL;
25425 }
25426
25427
25428 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25429 PyObject *resultobj = NULL;
25430 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25431 int result;
25432 PyObject * obj0 = 0 ;
25433 char *kwnames[] = {
25434 (char *) "self", NULL
25435 };
25436
25437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25439 if (SWIG_arg_fail(1)) SWIG_fail;
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 result = (int)(arg1)->GetFlags();
25443
25444 wxPyEndAllowThreads(__tstate);
25445 if (PyErr_Occurred()) SWIG_fail;
25446 }
25447 {
25448 resultobj = SWIG_From_int(static_cast<int >(result));
25449 }
25450 return resultobj;
25451 fail:
25452 return NULL;
25453 }
25454
25455
25456 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25457 PyObject *resultobj = NULL;
25458 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25459 int result;
25460 PyObject * obj0 = 0 ;
25461 char *kwnames[] = {
25462 (char *) "self", NULL
25463 };
25464
25465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25467 if (SWIG_arg_fail(1)) SWIG_fail;
25468 {
25469 PyThreadState* __tstate = wxPyBeginAllowThreads();
25470 result = (int)(arg1)->GetKeyCode();
25471
25472 wxPyEndAllowThreads(__tstate);
25473 if (PyErr_Occurred()) SWIG_fail;
25474 }
25475 {
25476 resultobj = SWIG_From_int(static_cast<int >(result));
25477 }
25478 return resultobj;
25479 fail:
25480 return NULL;
25481 }
25482
25483
25484 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25485 PyObject *resultobj = NULL;
25486 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25487 int result;
25488 PyObject * obj0 = 0 ;
25489 char *kwnames[] = {
25490 (char *) "self", NULL
25491 };
25492
25493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25495 if (SWIG_arg_fail(1)) SWIG_fail;
25496 {
25497 PyThreadState* __tstate = wxPyBeginAllowThreads();
25498 result = (int)(arg1)->GetCommand();
25499
25500 wxPyEndAllowThreads(__tstate);
25501 if (PyErr_Occurred()) SWIG_fail;
25502 }
25503 {
25504 resultobj = SWIG_From_int(static_cast<int >(result));
25505 }
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25513 PyObject *obj;
25514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25515 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25516 Py_INCREF(obj);
25517 return Py_BuildValue((char *)"");
25518 }
25519 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25520 PyObject *resultobj = NULL;
25521 int arg1 ;
25522 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25523 wxAcceleratorTable *result;
25524 PyObject * obj0 = 0 ;
25525 char *kwnames[] = {
25526 (char *) "n", NULL
25527 };
25528
25529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25530 {
25531 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25532 if (arg2) arg1 = PyList_Size(obj0);
25533 else arg1 = 0;
25534 }
25535 {
25536 PyThreadState* __tstate = wxPyBeginAllowThreads();
25537 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25538
25539 wxPyEndAllowThreads(__tstate);
25540 if (PyErr_Occurred()) SWIG_fail;
25541 }
25542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25543 {
25544 delete [] arg2;
25545 }
25546 return resultobj;
25547 fail:
25548 {
25549 delete [] arg2;
25550 }
25551 return NULL;
25552 }
25553
25554
25555 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25556 PyObject *resultobj = NULL;
25557 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25558 PyObject * obj0 = 0 ;
25559 char *kwnames[] = {
25560 (char *) "self", NULL
25561 };
25562
25563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25565 if (SWIG_arg_fail(1)) SWIG_fail;
25566 {
25567 PyThreadState* __tstate = wxPyBeginAllowThreads();
25568 delete arg1;
25569
25570 wxPyEndAllowThreads(__tstate);
25571 if (PyErr_Occurred()) SWIG_fail;
25572 }
25573 Py_INCREF(Py_None); resultobj = Py_None;
25574 return resultobj;
25575 fail:
25576 return NULL;
25577 }
25578
25579
25580 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25581 PyObject *resultobj = NULL;
25582 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25583 bool result;
25584 PyObject * obj0 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self", NULL
25587 };
25588
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25591 if (SWIG_arg_fail(1)) SWIG_fail;
25592 {
25593 PyThreadState* __tstate = wxPyBeginAllowThreads();
25594 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25595
25596 wxPyEndAllowThreads(__tstate);
25597 if (PyErr_Occurred()) SWIG_fail;
25598 }
25599 {
25600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25601 }
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25609 PyObject *obj;
25610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25611 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25612 Py_INCREF(obj);
25613 return Py_BuildValue((char *)"");
25614 }
25615 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25616 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25617 return 1;
25618 }
25619
25620
25621 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25622 PyObject *pyobj = NULL;
25623
25624 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25625 return pyobj;
25626 }
25627
25628
25629 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25630 PyObject *resultobj = NULL;
25631 wxString *arg1 = 0 ;
25632 wxAcceleratorEntry *result;
25633 bool temp1 = false ;
25634 PyObject * obj0 = 0 ;
25635 char *kwnames[] = {
25636 (char *) "label", NULL
25637 };
25638
25639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25640 {
25641 arg1 = wxString_in_helper(obj0);
25642 if (arg1 == NULL) SWIG_fail;
25643 temp1 = true;
25644 }
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25648
25649 wxPyEndAllowThreads(__tstate);
25650 if (PyErr_Occurred()) SWIG_fail;
25651 }
25652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25653 {
25654 if (temp1)
25655 delete arg1;
25656 }
25657 return resultobj;
25658 fail:
25659 {
25660 if (temp1)
25661 delete arg1;
25662 }
25663 return NULL;
25664 }
25665
25666
25667 static int _wrap_PanelNameStr_set(PyObject *) {
25668 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25669 return 1;
25670 }
25671
25672
25673 static PyObject *_wrap_PanelNameStr_get(void) {
25674 PyObject *pyobj = NULL;
25675
25676 {
25677 #if wxUSE_UNICODE
25678 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25679 #else
25680 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25681 #endif
25682 }
25683 return pyobj;
25684 }
25685
25686
25687 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj = NULL;
25689 wxVisualAttributes *result;
25690 char *kwnames[] = {
25691 NULL
25692 };
25693
25694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25695 {
25696 PyThreadState* __tstate = wxPyBeginAllowThreads();
25697 result = (wxVisualAttributes *)new_wxVisualAttributes();
25698
25699 wxPyEndAllowThreads(__tstate);
25700 if (PyErr_Occurred()) SWIG_fail;
25701 }
25702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25703 return resultobj;
25704 fail:
25705 return NULL;
25706 }
25707
25708
25709 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25710 PyObject *resultobj = NULL;
25711 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25712 PyObject * obj0 = 0 ;
25713 char *kwnames[] = {
25714 (char *) "self", NULL
25715 };
25716
25717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25719 if (SWIG_arg_fail(1)) SWIG_fail;
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 delete_wxVisualAttributes(arg1);
25723
25724 wxPyEndAllowThreads(__tstate);
25725 if (PyErr_Occurred()) SWIG_fail;
25726 }
25727 Py_INCREF(Py_None); resultobj = Py_None;
25728 return resultobj;
25729 fail:
25730 return NULL;
25731 }
25732
25733
25734 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25735 PyObject *resultobj = NULL;
25736 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25737 wxFont *arg2 = (wxFont *) 0 ;
25738 PyObject * obj0 = 0 ;
25739 PyObject * obj1 = 0 ;
25740 char *kwnames[] = {
25741 (char *) "self",(char *) "font", NULL
25742 };
25743
25744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25746 if (SWIG_arg_fail(1)) SWIG_fail;
25747 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25748 if (SWIG_arg_fail(2)) SWIG_fail;
25749 if (arg1) (arg1)->font = *arg2;
25750
25751 Py_INCREF(Py_None); resultobj = Py_None;
25752 return resultobj;
25753 fail:
25754 return NULL;
25755 }
25756
25757
25758 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25759 PyObject *resultobj = NULL;
25760 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25761 wxFont *result;
25762 PyObject * obj0 = 0 ;
25763 char *kwnames[] = {
25764 (char *) "self", NULL
25765 };
25766
25767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25769 if (SWIG_arg_fail(1)) SWIG_fail;
25770 result = (wxFont *)& ((arg1)->font);
25771
25772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25780 PyObject *resultobj = NULL;
25781 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25782 wxColour *arg2 = (wxColour *) 0 ;
25783 PyObject * obj0 = 0 ;
25784 PyObject * obj1 = 0 ;
25785 char *kwnames[] = {
25786 (char *) "self",(char *) "colFg", NULL
25787 };
25788
25789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25791 if (SWIG_arg_fail(1)) SWIG_fail;
25792 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25793 if (SWIG_arg_fail(2)) SWIG_fail;
25794 if (arg1) (arg1)->colFg = *arg2;
25795
25796 Py_INCREF(Py_None); resultobj = Py_None;
25797 return resultobj;
25798 fail:
25799 return NULL;
25800 }
25801
25802
25803 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25804 PyObject *resultobj = NULL;
25805 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25806 wxColour *result;
25807 PyObject * obj0 = 0 ;
25808 char *kwnames[] = {
25809 (char *) "self", NULL
25810 };
25811
25812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25814 if (SWIG_arg_fail(1)) SWIG_fail;
25815 result = (wxColour *)& ((arg1)->colFg);
25816
25817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25818 return resultobj;
25819 fail:
25820 return NULL;
25821 }
25822
25823
25824 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25825 PyObject *resultobj = NULL;
25826 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25827 wxColour *arg2 = (wxColour *) 0 ;
25828 PyObject * obj0 = 0 ;
25829 PyObject * obj1 = 0 ;
25830 char *kwnames[] = {
25831 (char *) "self",(char *) "colBg", NULL
25832 };
25833
25834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25836 if (SWIG_arg_fail(1)) SWIG_fail;
25837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25838 if (SWIG_arg_fail(2)) SWIG_fail;
25839 if (arg1) (arg1)->colBg = *arg2;
25840
25841 Py_INCREF(Py_None); resultobj = Py_None;
25842 return resultobj;
25843 fail:
25844 return NULL;
25845 }
25846
25847
25848 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25849 PyObject *resultobj = NULL;
25850 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25851 wxColour *result;
25852 PyObject * obj0 = 0 ;
25853 char *kwnames[] = {
25854 (char *) "self", NULL
25855 };
25856
25857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25859 if (SWIG_arg_fail(1)) SWIG_fail;
25860 result = (wxColour *)& ((arg1)->colBg);
25861
25862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25863 return resultobj;
25864 fail:
25865 return NULL;
25866 }
25867
25868
25869 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25870 PyObject *obj;
25871 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25872 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25873 Py_INCREF(obj);
25874 return Py_BuildValue((char *)"");
25875 }
25876 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj = NULL;
25878 wxWindow *arg1 = (wxWindow *) 0 ;
25879 int arg2 = (int) (int)-1 ;
25880 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25881 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25882 wxSize const &arg4_defvalue = wxDefaultSize ;
25883 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25884 long arg5 = (long) 0 ;
25885 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25886 wxString *arg6 = (wxString *) &arg6_defvalue ;
25887 wxWindow *result;
25888 wxPoint temp3 ;
25889 wxSize temp4 ;
25890 bool temp6 = false ;
25891 PyObject * obj0 = 0 ;
25892 PyObject * obj1 = 0 ;
25893 PyObject * obj2 = 0 ;
25894 PyObject * obj3 = 0 ;
25895 PyObject * obj4 = 0 ;
25896 PyObject * obj5 = 0 ;
25897 char *kwnames[] = {
25898 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25899 };
25900
25901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25903 if (SWIG_arg_fail(1)) SWIG_fail;
25904 if (obj1) {
25905 {
25906 arg2 = static_cast<int const >(SWIG_As_int(obj1));
25907 if (SWIG_arg_fail(2)) SWIG_fail;
25908 }
25909 }
25910 if (obj2) {
25911 {
25912 arg3 = &temp3;
25913 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25914 }
25915 }
25916 if (obj3) {
25917 {
25918 arg4 = &temp4;
25919 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25920 }
25921 }
25922 if (obj4) {
25923 {
25924 arg5 = static_cast<long >(SWIG_As_long(obj4));
25925 if (SWIG_arg_fail(5)) SWIG_fail;
25926 }
25927 }
25928 if (obj5) {
25929 {
25930 arg6 = wxString_in_helper(obj5);
25931 if (arg6 == NULL) SWIG_fail;
25932 temp6 = true;
25933 }
25934 }
25935 {
25936 if (!wxPyCheckForApp()) SWIG_fail;
25937 PyThreadState* __tstate = wxPyBeginAllowThreads();
25938 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25939
25940 wxPyEndAllowThreads(__tstate);
25941 if (PyErr_Occurred()) SWIG_fail;
25942 }
25943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25944 {
25945 if (temp6)
25946 delete arg6;
25947 }
25948 return resultobj;
25949 fail:
25950 {
25951 if (temp6)
25952 delete arg6;
25953 }
25954 return NULL;
25955 }
25956
25957
25958 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25959 PyObject *resultobj = NULL;
25960 wxWindow *result;
25961 char *kwnames[] = {
25962 NULL
25963 };
25964
25965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25966 {
25967 if (!wxPyCheckForApp()) SWIG_fail;
25968 PyThreadState* __tstate = wxPyBeginAllowThreads();
25969 result = (wxWindow *)new wxWindow();
25970
25971 wxPyEndAllowThreads(__tstate);
25972 if (PyErr_Occurred()) SWIG_fail;
25973 }
25974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25975 return resultobj;
25976 fail:
25977 return NULL;
25978 }
25979
25980
25981 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25982 PyObject *resultobj = NULL;
25983 wxWindow *arg1 = (wxWindow *) 0 ;
25984 wxWindow *arg2 = (wxWindow *) 0 ;
25985 int arg3 = (int) (int)-1 ;
25986 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25987 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25988 wxSize const &arg5_defvalue = wxDefaultSize ;
25989 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25990 long arg6 = (long) 0 ;
25991 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25992 wxString *arg7 = (wxString *) &arg7_defvalue ;
25993 bool result;
25994 wxPoint temp4 ;
25995 wxSize temp5 ;
25996 bool temp7 = false ;
25997 PyObject * obj0 = 0 ;
25998 PyObject * obj1 = 0 ;
25999 PyObject * obj2 = 0 ;
26000 PyObject * obj3 = 0 ;
26001 PyObject * obj4 = 0 ;
26002 PyObject * obj5 = 0 ;
26003 PyObject * obj6 = 0 ;
26004 char *kwnames[] = {
26005 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
26006 };
26007
26008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26010 if (SWIG_arg_fail(1)) SWIG_fail;
26011 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26012 if (SWIG_arg_fail(2)) SWIG_fail;
26013 if (obj2) {
26014 {
26015 arg3 = static_cast<int const >(SWIG_As_int(obj2));
26016 if (SWIG_arg_fail(3)) SWIG_fail;
26017 }
26018 }
26019 if (obj3) {
26020 {
26021 arg4 = &temp4;
26022 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
26023 }
26024 }
26025 if (obj4) {
26026 {
26027 arg5 = &temp5;
26028 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
26029 }
26030 }
26031 if (obj5) {
26032 {
26033 arg6 = static_cast<long >(SWIG_As_long(obj5));
26034 if (SWIG_arg_fail(6)) SWIG_fail;
26035 }
26036 }
26037 if (obj6) {
26038 {
26039 arg7 = wxString_in_helper(obj6);
26040 if (arg7 == NULL) SWIG_fail;
26041 temp7 = true;
26042 }
26043 }
26044 {
26045 PyThreadState* __tstate = wxPyBeginAllowThreads();
26046 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
26047
26048 wxPyEndAllowThreads(__tstate);
26049 if (PyErr_Occurred()) SWIG_fail;
26050 }
26051 {
26052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26053 }
26054 {
26055 if (temp7)
26056 delete arg7;
26057 }
26058 return resultobj;
26059 fail:
26060 {
26061 if (temp7)
26062 delete arg7;
26063 }
26064 return NULL;
26065 }
26066
26067
26068 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
26069 PyObject *resultobj = NULL;
26070 wxWindow *arg1 = (wxWindow *) 0 ;
26071 bool arg2 = (bool) false ;
26072 bool result;
26073 PyObject * obj0 = 0 ;
26074 PyObject * obj1 = 0 ;
26075 char *kwnames[] = {
26076 (char *) "self",(char *) "force", NULL
26077 };
26078
26079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
26080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26081 if (SWIG_arg_fail(1)) SWIG_fail;
26082 if (obj1) {
26083 {
26084 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
26085 if (SWIG_arg_fail(2)) SWIG_fail;
26086 }
26087 }
26088 {
26089 PyThreadState* __tstate = wxPyBeginAllowThreads();
26090 result = (bool)(arg1)->Close(arg2);
26091
26092 wxPyEndAllowThreads(__tstate);
26093 if (PyErr_Occurred()) SWIG_fail;
26094 }
26095 {
26096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26097 }
26098 return resultobj;
26099 fail:
26100 return NULL;
26101 }
26102
26103
26104 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26105 PyObject *resultobj = NULL;
26106 wxWindow *arg1 = (wxWindow *) 0 ;
26107 bool result;
26108 PyObject * obj0 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "self", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26115 if (SWIG_arg_fail(1)) SWIG_fail;
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 result = (bool)(arg1)->Destroy();
26119
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 {
26124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26125 }
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26133 PyObject *resultobj = NULL;
26134 wxWindow *arg1 = (wxWindow *) 0 ;
26135 bool result;
26136 PyObject * obj0 = 0 ;
26137 char *kwnames[] = {
26138 (char *) "self", NULL
26139 };
26140
26141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26143 if (SWIG_arg_fail(1)) SWIG_fail;
26144 {
26145 PyThreadState* __tstate = wxPyBeginAllowThreads();
26146 result = (bool)(arg1)->DestroyChildren();
26147
26148 wxPyEndAllowThreads(__tstate);
26149 if (PyErr_Occurred()) SWIG_fail;
26150 }
26151 {
26152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26153 }
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26161 PyObject *resultobj = NULL;
26162 wxWindow *arg1 = (wxWindow *) 0 ;
26163 bool result;
26164 PyObject * obj0 = 0 ;
26165 char *kwnames[] = {
26166 (char *) "self", NULL
26167 };
26168
26169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26171 if (SWIG_arg_fail(1)) SWIG_fail;
26172 {
26173 PyThreadState* __tstate = wxPyBeginAllowThreads();
26174 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26175
26176 wxPyEndAllowThreads(__tstate);
26177 if (PyErr_Occurred()) SWIG_fail;
26178 }
26179 {
26180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26181 }
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26189 PyObject *resultobj = NULL;
26190 wxWindow *arg1 = (wxWindow *) 0 ;
26191 wxString *arg2 = 0 ;
26192 bool temp2 = false ;
26193 PyObject * obj0 = 0 ;
26194 PyObject * obj1 = 0 ;
26195 char *kwnames[] = {
26196 (char *) "self",(char *) "label", NULL
26197 };
26198
26199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26201 if (SWIG_arg_fail(1)) SWIG_fail;
26202 {
26203 arg2 = wxString_in_helper(obj1);
26204 if (arg2 == NULL) SWIG_fail;
26205 temp2 = true;
26206 }
26207 {
26208 PyThreadState* __tstate = wxPyBeginAllowThreads();
26209 (arg1)->SetLabel((wxString const &)*arg2);
26210
26211 wxPyEndAllowThreads(__tstate);
26212 if (PyErr_Occurred()) SWIG_fail;
26213 }
26214 Py_INCREF(Py_None); resultobj = Py_None;
26215 {
26216 if (temp2)
26217 delete arg2;
26218 }
26219 return resultobj;
26220 fail:
26221 {
26222 if (temp2)
26223 delete arg2;
26224 }
26225 return NULL;
26226 }
26227
26228
26229 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26230 PyObject *resultobj = NULL;
26231 wxWindow *arg1 = (wxWindow *) 0 ;
26232 wxString result;
26233 PyObject * obj0 = 0 ;
26234 char *kwnames[] = {
26235 (char *) "self", NULL
26236 };
26237
26238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26240 if (SWIG_arg_fail(1)) SWIG_fail;
26241 {
26242 PyThreadState* __tstate = wxPyBeginAllowThreads();
26243 result = ((wxWindow const *)arg1)->GetLabel();
26244
26245 wxPyEndAllowThreads(__tstate);
26246 if (PyErr_Occurred()) SWIG_fail;
26247 }
26248 {
26249 #if wxUSE_UNICODE
26250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26251 #else
26252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26253 #endif
26254 }
26255 return resultobj;
26256 fail:
26257 return NULL;
26258 }
26259
26260
26261 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26262 PyObject *resultobj = NULL;
26263 wxWindow *arg1 = (wxWindow *) 0 ;
26264 wxString *arg2 = 0 ;
26265 bool temp2 = false ;
26266 PyObject * obj0 = 0 ;
26267 PyObject * obj1 = 0 ;
26268 char *kwnames[] = {
26269 (char *) "self",(char *) "name", NULL
26270 };
26271
26272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26274 if (SWIG_arg_fail(1)) SWIG_fail;
26275 {
26276 arg2 = wxString_in_helper(obj1);
26277 if (arg2 == NULL) SWIG_fail;
26278 temp2 = true;
26279 }
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 (arg1)->SetName((wxString const &)*arg2);
26283
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 Py_INCREF(Py_None); resultobj = Py_None;
26288 {
26289 if (temp2)
26290 delete arg2;
26291 }
26292 return resultobj;
26293 fail:
26294 {
26295 if (temp2)
26296 delete arg2;
26297 }
26298 return NULL;
26299 }
26300
26301
26302 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26303 PyObject *resultobj = NULL;
26304 wxWindow *arg1 = (wxWindow *) 0 ;
26305 wxString result;
26306 PyObject * obj0 = 0 ;
26307 char *kwnames[] = {
26308 (char *) "self", NULL
26309 };
26310
26311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26313 if (SWIG_arg_fail(1)) SWIG_fail;
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 result = ((wxWindow const *)arg1)->GetName();
26317
26318 wxPyEndAllowThreads(__tstate);
26319 if (PyErr_Occurred()) SWIG_fail;
26320 }
26321 {
26322 #if wxUSE_UNICODE
26323 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26324 #else
26325 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26326 #endif
26327 }
26328 return resultobj;
26329 fail:
26330 return NULL;
26331 }
26332
26333
26334 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26335 PyObject *resultobj = NULL;
26336 wxWindow *arg1 = (wxWindow *) 0 ;
26337 wxWindowVariant arg2 ;
26338 PyObject * obj0 = 0 ;
26339 PyObject * obj1 = 0 ;
26340 char *kwnames[] = {
26341 (char *) "self",(char *) "variant", NULL
26342 };
26343
26344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26346 if (SWIG_arg_fail(1)) SWIG_fail;
26347 {
26348 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26349 if (SWIG_arg_fail(2)) SWIG_fail;
26350 }
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 (arg1)->SetWindowVariant(arg2);
26354
26355 wxPyEndAllowThreads(__tstate);
26356 if (PyErr_Occurred()) SWIG_fail;
26357 }
26358 Py_INCREF(Py_None); resultobj = Py_None;
26359 return resultobj;
26360 fail:
26361 return NULL;
26362 }
26363
26364
26365 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26366 PyObject *resultobj = NULL;
26367 wxWindow *arg1 = (wxWindow *) 0 ;
26368 wxWindowVariant result;
26369 PyObject * obj0 = 0 ;
26370 char *kwnames[] = {
26371 (char *) "self", NULL
26372 };
26373
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26376 if (SWIG_arg_fail(1)) SWIG_fail;
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26380
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 resultobj = SWIG_From_int((result));
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26392 PyObject *resultobj = NULL;
26393 wxWindow *arg1 = (wxWindow *) 0 ;
26394 int arg2 ;
26395 PyObject * obj0 = 0 ;
26396 PyObject * obj1 = 0 ;
26397 char *kwnames[] = {
26398 (char *) "self",(char *) "winid", NULL
26399 };
26400
26401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26403 if (SWIG_arg_fail(1)) SWIG_fail;
26404 {
26405 arg2 = static_cast<int >(SWIG_As_int(obj1));
26406 if (SWIG_arg_fail(2)) SWIG_fail;
26407 }
26408 {
26409 PyThreadState* __tstate = wxPyBeginAllowThreads();
26410 (arg1)->SetId(arg2);
26411
26412 wxPyEndAllowThreads(__tstate);
26413 if (PyErr_Occurred()) SWIG_fail;
26414 }
26415 Py_INCREF(Py_None); resultobj = Py_None;
26416 return resultobj;
26417 fail:
26418 return NULL;
26419 }
26420
26421
26422 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26423 PyObject *resultobj = NULL;
26424 wxWindow *arg1 = (wxWindow *) 0 ;
26425 int result;
26426 PyObject * obj0 = 0 ;
26427 char *kwnames[] = {
26428 (char *) "self", NULL
26429 };
26430
26431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26433 if (SWIG_arg_fail(1)) SWIG_fail;
26434 {
26435 PyThreadState* __tstate = wxPyBeginAllowThreads();
26436 result = (int)((wxWindow const *)arg1)->GetId();
26437
26438 wxPyEndAllowThreads(__tstate);
26439 if (PyErr_Occurred()) SWIG_fail;
26440 }
26441 {
26442 resultobj = SWIG_From_int(static_cast<int >(result));
26443 }
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26451 PyObject *resultobj = NULL;
26452 int result;
26453 char *kwnames[] = {
26454 NULL
26455 };
26456
26457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26458 {
26459 PyThreadState* __tstate = wxPyBeginAllowThreads();
26460 result = (int)wxWindow::NewControlId();
26461
26462 wxPyEndAllowThreads(__tstate);
26463 if (PyErr_Occurred()) SWIG_fail;
26464 }
26465 {
26466 resultobj = SWIG_From_int(static_cast<int >(result));
26467 }
26468 return resultobj;
26469 fail:
26470 return NULL;
26471 }
26472
26473
26474 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26475 PyObject *resultobj = NULL;
26476 int arg1 ;
26477 int result;
26478 PyObject * obj0 = 0 ;
26479 char *kwnames[] = {
26480 (char *) "winid", NULL
26481 };
26482
26483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26484 {
26485 arg1 = static_cast<int >(SWIG_As_int(obj0));
26486 if (SWIG_arg_fail(1)) SWIG_fail;
26487 }
26488 {
26489 PyThreadState* __tstate = wxPyBeginAllowThreads();
26490 result = (int)wxWindow::NextControlId(arg1);
26491
26492 wxPyEndAllowThreads(__tstate);
26493 if (PyErr_Occurred()) SWIG_fail;
26494 }
26495 {
26496 resultobj = SWIG_From_int(static_cast<int >(result));
26497 }
26498 return resultobj;
26499 fail:
26500 return NULL;
26501 }
26502
26503
26504 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26505 PyObject *resultobj = NULL;
26506 int arg1 ;
26507 int result;
26508 PyObject * obj0 = 0 ;
26509 char *kwnames[] = {
26510 (char *) "winid", NULL
26511 };
26512
26513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26514 {
26515 arg1 = static_cast<int >(SWIG_As_int(obj0));
26516 if (SWIG_arg_fail(1)) SWIG_fail;
26517 }
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (int)wxWindow::PrevControlId(arg1);
26521
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 {
26526 resultobj = SWIG_From_int(static_cast<int >(result));
26527 }
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj = NULL;
26536 wxWindow *arg1 = (wxWindow *) 0 ;
26537 wxSize *arg2 = 0 ;
26538 wxSize temp2 ;
26539 PyObject * obj0 = 0 ;
26540 PyObject * obj1 = 0 ;
26541 char *kwnames[] = {
26542 (char *) "self",(char *) "size", NULL
26543 };
26544
26545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26547 if (SWIG_arg_fail(1)) SWIG_fail;
26548 {
26549 arg2 = &temp2;
26550 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26551 }
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 (arg1)->SetSize((wxSize const &)*arg2);
26555
26556 wxPyEndAllowThreads(__tstate);
26557 if (PyErr_Occurred()) SWIG_fail;
26558 }
26559 Py_INCREF(Py_None); resultobj = Py_None;
26560 return resultobj;
26561 fail:
26562 return NULL;
26563 }
26564
26565
26566 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26567 PyObject *resultobj = NULL;
26568 wxWindow *arg1 = (wxWindow *) 0 ;
26569 int arg2 ;
26570 int arg3 ;
26571 int arg4 ;
26572 int arg5 ;
26573 int arg6 = (int) wxSIZE_AUTO ;
26574 PyObject * obj0 = 0 ;
26575 PyObject * obj1 = 0 ;
26576 PyObject * obj2 = 0 ;
26577 PyObject * obj3 = 0 ;
26578 PyObject * obj4 = 0 ;
26579 PyObject * obj5 = 0 ;
26580 char *kwnames[] = {
26581 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26582 };
26583
26584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26586 if (SWIG_arg_fail(1)) SWIG_fail;
26587 {
26588 arg2 = static_cast<int >(SWIG_As_int(obj1));
26589 if (SWIG_arg_fail(2)) SWIG_fail;
26590 }
26591 {
26592 arg3 = static_cast<int >(SWIG_As_int(obj2));
26593 if (SWIG_arg_fail(3)) SWIG_fail;
26594 }
26595 {
26596 arg4 = static_cast<int >(SWIG_As_int(obj3));
26597 if (SWIG_arg_fail(4)) SWIG_fail;
26598 }
26599 {
26600 arg5 = static_cast<int >(SWIG_As_int(obj4));
26601 if (SWIG_arg_fail(5)) SWIG_fail;
26602 }
26603 if (obj5) {
26604 {
26605 arg6 = static_cast<int >(SWIG_As_int(obj5));
26606 if (SWIG_arg_fail(6)) SWIG_fail;
26607 }
26608 }
26609 {
26610 PyThreadState* __tstate = wxPyBeginAllowThreads();
26611 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26612
26613 wxPyEndAllowThreads(__tstate);
26614 if (PyErr_Occurred()) SWIG_fail;
26615 }
26616 Py_INCREF(Py_None); resultobj = Py_None;
26617 return resultobj;
26618 fail:
26619 return NULL;
26620 }
26621
26622
26623 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26624 PyObject *resultobj = NULL;
26625 wxWindow *arg1 = (wxWindow *) 0 ;
26626 wxRect *arg2 = 0 ;
26627 int arg3 = (int) wxSIZE_AUTO ;
26628 wxRect temp2 ;
26629 PyObject * obj0 = 0 ;
26630 PyObject * obj1 = 0 ;
26631 PyObject * obj2 = 0 ;
26632 char *kwnames[] = {
26633 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26634 };
26635
26636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26638 if (SWIG_arg_fail(1)) SWIG_fail;
26639 {
26640 arg2 = &temp2;
26641 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26642 }
26643 if (obj2) {
26644 {
26645 arg3 = static_cast<int >(SWIG_As_int(obj2));
26646 if (SWIG_arg_fail(3)) SWIG_fail;
26647 }
26648 }
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26652
26653 wxPyEndAllowThreads(__tstate);
26654 if (PyErr_Occurred()) SWIG_fail;
26655 }
26656 Py_INCREF(Py_None); resultobj = Py_None;
26657 return resultobj;
26658 fail:
26659 return NULL;
26660 }
26661
26662
26663 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26664 PyObject *resultobj = NULL;
26665 wxWindow *arg1 = (wxWindow *) 0 ;
26666 int arg2 ;
26667 int arg3 ;
26668 PyObject * obj0 = 0 ;
26669 PyObject * obj1 = 0 ;
26670 PyObject * obj2 = 0 ;
26671 char *kwnames[] = {
26672 (char *) "self",(char *) "width",(char *) "height", NULL
26673 };
26674
26675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26677 if (SWIG_arg_fail(1)) SWIG_fail;
26678 {
26679 arg2 = static_cast<int >(SWIG_As_int(obj1));
26680 if (SWIG_arg_fail(2)) SWIG_fail;
26681 }
26682 {
26683 arg3 = static_cast<int >(SWIG_As_int(obj2));
26684 if (SWIG_arg_fail(3)) SWIG_fail;
26685 }
26686 {
26687 PyThreadState* __tstate = wxPyBeginAllowThreads();
26688 (arg1)->SetSize(arg2,arg3);
26689
26690 wxPyEndAllowThreads(__tstate);
26691 if (PyErr_Occurred()) SWIG_fail;
26692 }
26693 Py_INCREF(Py_None); resultobj = Py_None;
26694 return resultobj;
26695 fail:
26696 return NULL;
26697 }
26698
26699
26700 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26701 PyObject *resultobj = NULL;
26702 wxWindow *arg1 = (wxWindow *) 0 ;
26703 wxPoint *arg2 = 0 ;
26704 int arg3 = (int) wxSIZE_USE_EXISTING ;
26705 wxPoint temp2 ;
26706 PyObject * obj0 = 0 ;
26707 PyObject * obj1 = 0 ;
26708 PyObject * obj2 = 0 ;
26709 char *kwnames[] = {
26710 (char *) "self",(char *) "pt",(char *) "flags", NULL
26711 };
26712
26713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26715 if (SWIG_arg_fail(1)) SWIG_fail;
26716 {
26717 arg2 = &temp2;
26718 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26719 }
26720 if (obj2) {
26721 {
26722 arg3 = static_cast<int >(SWIG_As_int(obj2));
26723 if (SWIG_arg_fail(3)) SWIG_fail;
26724 }
26725 }
26726 {
26727 PyThreadState* __tstate = wxPyBeginAllowThreads();
26728 (arg1)->Move((wxPoint const &)*arg2,arg3);
26729
26730 wxPyEndAllowThreads(__tstate);
26731 if (PyErr_Occurred()) SWIG_fail;
26732 }
26733 Py_INCREF(Py_None); resultobj = Py_None;
26734 return resultobj;
26735 fail:
26736 return NULL;
26737 }
26738
26739
26740 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26741 PyObject *resultobj = NULL;
26742 wxWindow *arg1 = (wxWindow *) 0 ;
26743 int arg2 ;
26744 int arg3 ;
26745 int arg4 = (int) wxSIZE_USE_EXISTING ;
26746 PyObject * obj0 = 0 ;
26747 PyObject * obj1 = 0 ;
26748 PyObject * obj2 = 0 ;
26749 PyObject * obj3 = 0 ;
26750 char *kwnames[] = {
26751 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26752 };
26753
26754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26756 if (SWIG_arg_fail(1)) SWIG_fail;
26757 {
26758 arg2 = static_cast<int >(SWIG_As_int(obj1));
26759 if (SWIG_arg_fail(2)) SWIG_fail;
26760 }
26761 {
26762 arg3 = static_cast<int >(SWIG_As_int(obj2));
26763 if (SWIG_arg_fail(3)) SWIG_fail;
26764 }
26765 if (obj3) {
26766 {
26767 arg4 = static_cast<int >(SWIG_As_int(obj3));
26768 if (SWIG_arg_fail(4)) SWIG_fail;
26769 }
26770 }
26771 {
26772 PyThreadState* __tstate = wxPyBeginAllowThreads();
26773 (arg1)->Move(arg2,arg3,arg4);
26774
26775 wxPyEndAllowThreads(__tstate);
26776 if (PyErr_Occurred()) SWIG_fail;
26777 }
26778 Py_INCREF(Py_None); resultobj = Py_None;
26779 return resultobj;
26780 fail:
26781 return NULL;
26782 }
26783
26784
26785 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26786 PyObject *resultobj = NULL;
26787 wxWindow *arg1 = (wxWindow *) 0 ;
26788 wxSize const &arg2_defvalue = wxDefaultSize ;
26789 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26790 wxSize temp2 ;
26791 PyObject * obj0 = 0 ;
26792 PyObject * obj1 = 0 ;
26793 char *kwnames[] = {
26794 (char *) "self",(char *) "size", NULL
26795 };
26796
26797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26799 if (SWIG_arg_fail(1)) SWIG_fail;
26800 if (obj1) {
26801 {
26802 arg2 = &temp2;
26803 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26804 }
26805 }
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26809
26810 wxPyEndAllowThreads(__tstate);
26811 if (PyErr_Occurred()) SWIG_fail;
26812 }
26813 Py_INCREF(Py_None); resultobj = Py_None;
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj = NULL;
26822 wxWindow *arg1 = (wxWindow *) 0 ;
26823 PyObject * obj0 = 0 ;
26824 char *kwnames[] = {
26825 (char *) "self", NULL
26826 };
26827
26828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26830 if (SWIG_arg_fail(1)) SWIG_fail;
26831 {
26832 PyThreadState* __tstate = wxPyBeginAllowThreads();
26833 (arg1)->Raise();
26834
26835 wxPyEndAllowThreads(__tstate);
26836 if (PyErr_Occurred()) SWIG_fail;
26837 }
26838 Py_INCREF(Py_None); resultobj = Py_None;
26839 return resultobj;
26840 fail:
26841 return NULL;
26842 }
26843
26844
26845 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26846 PyObject *resultobj = NULL;
26847 wxWindow *arg1 = (wxWindow *) 0 ;
26848 PyObject * obj0 = 0 ;
26849 char *kwnames[] = {
26850 (char *) "self", NULL
26851 };
26852
26853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26855 if (SWIG_arg_fail(1)) SWIG_fail;
26856 {
26857 PyThreadState* __tstate = wxPyBeginAllowThreads();
26858 (arg1)->Lower();
26859
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 Py_INCREF(Py_None); resultobj = Py_None;
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26871 PyObject *resultobj = NULL;
26872 wxWindow *arg1 = (wxWindow *) 0 ;
26873 wxSize *arg2 = 0 ;
26874 wxSize temp2 ;
26875 PyObject * obj0 = 0 ;
26876 PyObject * obj1 = 0 ;
26877 char *kwnames[] = {
26878 (char *) "self",(char *) "size", NULL
26879 };
26880
26881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26883 if (SWIG_arg_fail(1)) SWIG_fail;
26884 {
26885 arg2 = &temp2;
26886 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26887 }
26888 {
26889 PyThreadState* __tstate = wxPyBeginAllowThreads();
26890 (arg1)->SetClientSize((wxSize const &)*arg2);
26891
26892 wxPyEndAllowThreads(__tstate);
26893 if (PyErr_Occurred()) SWIG_fail;
26894 }
26895 Py_INCREF(Py_None); resultobj = Py_None;
26896 return resultobj;
26897 fail:
26898 return NULL;
26899 }
26900
26901
26902 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj = NULL;
26904 wxWindow *arg1 = (wxWindow *) 0 ;
26905 int arg2 ;
26906 int arg3 ;
26907 PyObject * obj0 = 0 ;
26908 PyObject * obj1 = 0 ;
26909 PyObject * obj2 = 0 ;
26910 char *kwnames[] = {
26911 (char *) "self",(char *) "width",(char *) "height", NULL
26912 };
26913
26914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26916 if (SWIG_arg_fail(1)) SWIG_fail;
26917 {
26918 arg2 = static_cast<int >(SWIG_As_int(obj1));
26919 if (SWIG_arg_fail(2)) SWIG_fail;
26920 }
26921 {
26922 arg3 = static_cast<int >(SWIG_As_int(obj2));
26923 if (SWIG_arg_fail(3)) SWIG_fail;
26924 }
26925 {
26926 PyThreadState* __tstate = wxPyBeginAllowThreads();
26927 (arg1)->SetClientSize(arg2,arg3);
26928
26929 wxPyEndAllowThreads(__tstate);
26930 if (PyErr_Occurred()) SWIG_fail;
26931 }
26932 Py_INCREF(Py_None); resultobj = Py_None;
26933 return resultobj;
26934 fail:
26935 return NULL;
26936 }
26937
26938
26939 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26940 PyObject *resultobj = NULL;
26941 wxWindow *arg1 = (wxWindow *) 0 ;
26942 wxRect *arg2 = 0 ;
26943 wxRect temp2 ;
26944 PyObject * obj0 = 0 ;
26945 PyObject * obj1 = 0 ;
26946 char *kwnames[] = {
26947 (char *) "self",(char *) "rect", NULL
26948 };
26949
26950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26952 if (SWIG_arg_fail(1)) SWIG_fail;
26953 {
26954 arg2 = &temp2;
26955 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26956 }
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 (arg1)->SetClientSize((wxRect const &)*arg2);
26960
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 Py_INCREF(Py_None); resultobj = Py_None;
26965 return resultobj;
26966 fail:
26967 return NULL;
26968 }
26969
26970
26971 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26972 PyObject *resultobj = NULL;
26973 wxWindow *arg1 = (wxWindow *) 0 ;
26974 wxPoint result;
26975 PyObject * obj0 = 0 ;
26976 char *kwnames[] = {
26977 (char *) "self", NULL
26978 };
26979
26980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26982 if (SWIG_arg_fail(1)) SWIG_fail;
26983 {
26984 PyThreadState* __tstate = wxPyBeginAllowThreads();
26985 result = (arg1)->GetPosition();
26986
26987 wxPyEndAllowThreads(__tstate);
26988 if (PyErr_Occurred()) SWIG_fail;
26989 }
26990 {
26991 wxPoint * resultptr;
26992 resultptr = new wxPoint(static_cast<wxPoint & >(result));
26993 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26994 }
26995 return resultobj;
26996 fail:
26997 return NULL;
26998 }
26999
27000
27001 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27002 PyObject *resultobj = NULL;
27003 wxWindow *arg1 = (wxWindow *) 0 ;
27004 int *arg2 = (int *) 0 ;
27005 int *arg3 = (int *) 0 ;
27006 int temp2 ;
27007 int res2 = 0 ;
27008 int temp3 ;
27009 int res3 = 0 ;
27010 PyObject * obj0 = 0 ;
27011 char *kwnames[] = {
27012 (char *) "self", NULL
27013 };
27014
27015 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27016 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
27018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27019 if (SWIG_arg_fail(1)) SWIG_fail;
27020 {
27021 PyThreadState* __tstate = wxPyBeginAllowThreads();
27022 (arg1)->GetPosition(arg2,arg3);
27023
27024 wxPyEndAllowThreads(__tstate);
27025 if (PyErr_Occurred()) SWIG_fail;
27026 }
27027 Py_INCREF(Py_None); resultobj = Py_None;
27028 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27029 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27030 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27031 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27032 return resultobj;
27033 fail:
27034 return NULL;
27035 }
27036
27037
27038 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
27039 PyObject *resultobj = NULL;
27040 wxWindow *arg1 = (wxWindow *) 0 ;
27041 wxSize result;
27042 PyObject * obj0 = 0 ;
27043 char *kwnames[] = {
27044 (char *) "self", NULL
27045 };
27046
27047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
27048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27049 if (SWIG_arg_fail(1)) SWIG_fail;
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 result = ((wxWindow const *)arg1)->GetSize();
27053
27054 wxPyEndAllowThreads(__tstate);
27055 if (PyErr_Occurred()) SWIG_fail;
27056 }
27057 {
27058 wxSize * resultptr;
27059 resultptr = new wxSize(static_cast<wxSize & >(result));
27060 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27061 }
27062 return resultobj;
27063 fail:
27064 return NULL;
27065 }
27066
27067
27068 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27069 PyObject *resultobj = NULL;
27070 wxWindow *arg1 = (wxWindow *) 0 ;
27071 int *arg2 = (int *) 0 ;
27072 int *arg3 = (int *) 0 ;
27073 int temp2 ;
27074 int res2 = 0 ;
27075 int temp3 ;
27076 int res3 = 0 ;
27077 PyObject * obj0 = 0 ;
27078 char *kwnames[] = {
27079 (char *) "self", NULL
27080 };
27081
27082 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27083 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
27085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27086 if (SWIG_arg_fail(1)) SWIG_fail;
27087 {
27088 PyThreadState* __tstate = wxPyBeginAllowThreads();
27089 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27090
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 Py_INCREF(Py_None); resultobj = Py_None;
27095 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27096 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27097 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27098 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27099 return resultobj;
27100 fail:
27101 return NULL;
27102 }
27103
27104
27105 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27106 PyObject *resultobj = NULL;
27107 wxWindow *arg1 = (wxWindow *) 0 ;
27108 wxRect result;
27109 PyObject * obj0 = 0 ;
27110 char *kwnames[] = {
27111 (char *) "self", NULL
27112 };
27113
27114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27116 if (SWIG_arg_fail(1)) SWIG_fail;
27117 {
27118 PyThreadState* __tstate = wxPyBeginAllowThreads();
27119 result = ((wxWindow const *)arg1)->GetRect();
27120
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 {
27125 wxRect * resultptr;
27126 resultptr = new wxRect(static_cast<wxRect & >(result));
27127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27128 }
27129 return resultobj;
27130 fail:
27131 return NULL;
27132 }
27133
27134
27135 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27136 PyObject *resultobj = NULL;
27137 wxWindow *arg1 = (wxWindow *) 0 ;
27138 wxSize result;
27139 PyObject * obj0 = 0 ;
27140 char *kwnames[] = {
27141 (char *) "self", NULL
27142 };
27143
27144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
27145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27146 if (SWIG_arg_fail(1)) SWIG_fail;
27147 {
27148 PyThreadState* __tstate = wxPyBeginAllowThreads();
27149 result = ((wxWindow const *)arg1)->GetClientSize();
27150
27151 wxPyEndAllowThreads(__tstate);
27152 if (PyErr_Occurred()) SWIG_fail;
27153 }
27154 {
27155 wxSize * resultptr;
27156 resultptr = new wxSize(static_cast<wxSize & >(result));
27157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27158 }
27159 return resultobj;
27160 fail:
27161 return NULL;
27162 }
27163
27164
27165 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27166 PyObject *resultobj = NULL;
27167 wxWindow *arg1 = (wxWindow *) 0 ;
27168 int *arg2 = (int *) 0 ;
27169 int *arg3 = (int *) 0 ;
27170 int temp2 ;
27171 int res2 = 0 ;
27172 int temp3 ;
27173 int res3 = 0 ;
27174 PyObject * obj0 = 0 ;
27175 char *kwnames[] = {
27176 (char *) "self", NULL
27177 };
27178
27179 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27180 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27183 if (SWIG_arg_fail(1)) SWIG_fail;
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27187
27188 wxPyEndAllowThreads(__tstate);
27189 if (PyErr_Occurred()) SWIG_fail;
27190 }
27191 Py_INCREF(Py_None); resultobj = Py_None;
27192 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27193 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27194 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27195 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27196 return resultobj;
27197 fail:
27198 return NULL;
27199 }
27200
27201
27202 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27203 PyObject *resultobj = NULL;
27204 wxWindow *arg1 = (wxWindow *) 0 ;
27205 wxPoint result;
27206 PyObject * obj0 = 0 ;
27207 char *kwnames[] = {
27208 (char *) "self", NULL
27209 };
27210
27211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27213 if (SWIG_arg_fail(1)) SWIG_fail;
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27217
27218 wxPyEndAllowThreads(__tstate);
27219 if (PyErr_Occurred()) SWIG_fail;
27220 }
27221 {
27222 wxPoint * resultptr;
27223 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27225 }
27226 return resultobj;
27227 fail:
27228 return NULL;
27229 }
27230
27231
27232 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27233 PyObject *resultobj = NULL;
27234 wxWindow *arg1 = (wxWindow *) 0 ;
27235 wxRect result;
27236 PyObject * obj0 = 0 ;
27237 char *kwnames[] = {
27238 (char *) "self", NULL
27239 };
27240
27241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27243 if (SWIG_arg_fail(1)) SWIG_fail;
27244 {
27245 PyThreadState* __tstate = wxPyBeginAllowThreads();
27246 result = ((wxWindow const *)arg1)->GetClientRect();
27247
27248 wxPyEndAllowThreads(__tstate);
27249 if (PyErr_Occurred()) SWIG_fail;
27250 }
27251 {
27252 wxRect * resultptr;
27253 resultptr = new wxRect(static_cast<wxRect & >(result));
27254 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27255 }
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27263 PyObject *resultobj = NULL;
27264 wxWindow *arg1 = (wxWindow *) 0 ;
27265 wxSize result;
27266 PyObject * obj0 = 0 ;
27267 char *kwnames[] = {
27268 (char *) "self", NULL
27269 };
27270
27271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27273 if (SWIG_arg_fail(1)) SWIG_fail;
27274 {
27275 PyThreadState* __tstate = wxPyBeginAllowThreads();
27276 result = ((wxWindow const *)arg1)->GetBestSize();
27277
27278 wxPyEndAllowThreads(__tstate);
27279 if (PyErr_Occurred()) SWIG_fail;
27280 }
27281 {
27282 wxSize * resultptr;
27283 resultptr = new wxSize(static_cast<wxSize & >(result));
27284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27285 }
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27293 PyObject *resultobj = NULL;
27294 wxWindow *arg1 = (wxWindow *) 0 ;
27295 int *arg2 = (int *) 0 ;
27296 int *arg3 = (int *) 0 ;
27297 int temp2 ;
27298 int res2 = 0 ;
27299 int temp3 ;
27300 int res3 = 0 ;
27301 PyObject * obj0 = 0 ;
27302 char *kwnames[] = {
27303 (char *) "self", NULL
27304 };
27305
27306 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27307 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27310 if (SWIG_arg_fail(1)) SWIG_fail;
27311 {
27312 PyThreadState* __tstate = wxPyBeginAllowThreads();
27313 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27314
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 Py_INCREF(Py_None); resultobj = Py_None;
27319 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27320 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27321 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27322 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27323 return resultobj;
27324 fail:
27325 return NULL;
27326 }
27327
27328
27329 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27330 PyObject *resultobj = NULL;
27331 wxWindow *arg1 = (wxWindow *) 0 ;
27332 PyObject * obj0 = 0 ;
27333 char *kwnames[] = {
27334 (char *) "self", NULL
27335 };
27336
27337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",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 (arg1)->InvalidateBestSize();
27343
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 Py_INCREF(Py_None); resultobj = Py_None;
27348 return resultobj;
27349 fail:
27350 return NULL;
27351 }
27352
27353
27354 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27355 PyObject *resultobj = NULL;
27356 wxWindow *arg1 = (wxWindow *) 0 ;
27357 wxSize *arg2 = 0 ;
27358 wxSize temp2 ;
27359 PyObject * obj0 = 0 ;
27360 PyObject * obj1 = 0 ;
27361 char *kwnames[] = {
27362 (char *) "self",(char *) "size", NULL
27363 };
27364
27365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27367 if (SWIG_arg_fail(1)) SWIG_fail;
27368 {
27369 arg2 = &temp2;
27370 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27371 }
27372 {
27373 PyThreadState* __tstate = wxPyBeginAllowThreads();
27374 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27375
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 Py_INCREF(Py_None); resultobj = Py_None;
27380 return resultobj;
27381 fail:
27382 return NULL;
27383 }
27384
27385
27386 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27387 PyObject *resultobj = NULL;
27388 wxWindow *arg1 = (wxWindow *) 0 ;
27389 wxSize result;
27390 PyObject * obj0 = 0 ;
27391 char *kwnames[] = {
27392 (char *) "self", NULL
27393 };
27394
27395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27397 if (SWIG_arg_fail(1)) SWIG_fail;
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27401
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 wxSize * resultptr;
27407 resultptr = new wxSize(static_cast<wxSize & >(result));
27408 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27409 }
27410 return resultobj;
27411 fail:
27412 return NULL;
27413 }
27414
27415
27416 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27417 PyObject *resultobj = NULL;
27418 wxWindow *arg1 = (wxWindow *) 0 ;
27419 wxSize result;
27420 PyObject * obj0 = 0 ;
27421 char *kwnames[] = {
27422 (char *) "self", NULL
27423 };
27424
27425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27427 if (SWIG_arg_fail(1)) SWIG_fail;
27428 {
27429 PyThreadState* __tstate = wxPyBeginAllowThreads();
27430 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27431
27432 wxPyEndAllowThreads(__tstate);
27433 if (PyErr_Occurred()) SWIG_fail;
27434 }
27435 {
27436 wxSize * resultptr;
27437 resultptr = new wxSize(static_cast<wxSize & >(result));
27438 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27439 }
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj = NULL;
27448 wxWindow *arg1 = (wxWindow *) 0 ;
27449 int arg2 = (int) wxBOTH ;
27450 PyObject * obj0 = 0 ;
27451 PyObject * obj1 = 0 ;
27452 char *kwnames[] = {
27453 (char *) "self",(char *) "direction", NULL
27454 };
27455
27456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27458 if (SWIG_arg_fail(1)) SWIG_fail;
27459 if (obj1) {
27460 {
27461 arg2 = static_cast<int >(SWIG_As_int(obj1));
27462 if (SWIG_arg_fail(2)) SWIG_fail;
27463 }
27464 }
27465 {
27466 PyThreadState* __tstate = wxPyBeginAllowThreads();
27467 (arg1)->Center(arg2);
27468
27469 wxPyEndAllowThreads(__tstate);
27470 if (PyErr_Occurred()) SWIG_fail;
27471 }
27472 Py_INCREF(Py_None); resultobj = Py_None;
27473 return resultobj;
27474 fail:
27475 return NULL;
27476 }
27477
27478
27479 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27480 PyObject *resultobj = NULL;
27481 wxWindow *arg1 = (wxWindow *) 0 ;
27482 int arg2 = (int) wxBOTH ;
27483 PyObject * obj0 = 0 ;
27484 PyObject * obj1 = 0 ;
27485 char *kwnames[] = {
27486 (char *) "self",(char *) "dir", NULL
27487 };
27488
27489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27491 if (SWIG_arg_fail(1)) SWIG_fail;
27492 if (obj1) {
27493 {
27494 arg2 = static_cast<int >(SWIG_As_int(obj1));
27495 if (SWIG_arg_fail(2)) SWIG_fail;
27496 }
27497 }
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 (arg1)->CenterOnParent(arg2);
27501
27502 wxPyEndAllowThreads(__tstate);
27503 if (PyErr_Occurred()) SWIG_fail;
27504 }
27505 Py_INCREF(Py_None); resultobj = Py_None;
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = NULL;
27514 wxWindow *arg1 = (wxWindow *) 0 ;
27515 PyObject * obj0 = 0 ;
27516 char *kwnames[] = {
27517 (char *) "self", NULL
27518 };
27519
27520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27522 if (SWIG_arg_fail(1)) SWIG_fail;
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 (arg1)->Fit();
27526
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 Py_INCREF(Py_None); resultobj = Py_None;
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27538 PyObject *resultobj = NULL;
27539 wxWindow *arg1 = (wxWindow *) 0 ;
27540 PyObject * obj0 = 0 ;
27541 char *kwnames[] = {
27542 (char *) "self", NULL
27543 };
27544
27545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27547 if (SWIG_arg_fail(1)) SWIG_fail;
27548 {
27549 PyThreadState* __tstate = wxPyBeginAllowThreads();
27550 (arg1)->FitInside();
27551
27552 wxPyEndAllowThreads(__tstate);
27553 if (PyErr_Occurred()) SWIG_fail;
27554 }
27555 Py_INCREF(Py_None); resultobj = Py_None;
27556 return resultobj;
27557 fail:
27558 return NULL;
27559 }
27560
27561
27562 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27563 PyObject *resultobj = NULL;
27564 wxWindow *arg1 = (wxWindow *) 0 ;
27565 int arg2 ;
27566 int arg3 ;
27567 int arg4 = (int) -1 ;
27568 int arg5 = (int) -1 ;
27569 int arg6 = (int) -1 ;
27570 int arg7 = (int) -1 ;
27571 PyObject * obj0 = 0 ;
27572 PyObject * obj1 = 0 ;
27573 PyObject * obj2 = 0 ;
27574 PyObject * obj3 = 0 ;
27575 PyObject * obj4 = 0 ;
27576 PyObject * obj5 = 0 ;
27577 PyObject * obj6 = 0 ;
27578 char *kwnames[] = {
27579 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27580 };
27581
27582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27584 if (SWIG_arg_fail(1)) SWIG_fail;
27585 {
27586 arg2 = static_cast<int >(SWIG_As_int(obj1));
27587 if (SWIG_arg_fail(2)) SWIG_fail;
27588 }
27589 {
27590 arg3 = static_cast<int >(SWIG_As_int(obj2));
27591 if (SWIG_arg_fail(3)) SWIG_fail;
27592 }
27593 if (obj3) {
27594 {
27595 arg4 = static_cast<int >(SWIG_As_int(obj3));
27596 if (SWIG_arg_fail(4)) SWIG_fail;
27597 }
27598 }
27599 if (obj4) {
27600 {
27601 arg5 = static_cast<int >(SWIG_As_int(obj4));
27602 if (SWIG_arg_fail(5)) SWIG_fail;
27603 }
27604 }
27605 if (obj5) {
27606 {
27607 arg6 = static_cast<int >(SWIG_As_int(obj5));
27608 if (SWIG_arg_fail(6)) SWIG_fail;
27609 }
27610 }
27611 if (obj6) {
27612 {
27613 arg7 = static_cast<int >(SWIG_As_int(obj6));
27614 if (SWIG_arg_fail(7)) SWIG_fail;
27615 }
27616 }
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27620
27621 wxPyEndAllowThreads(__tstate);
27622 if (PyErr_Occurred()) SWIG_fail;
27623 }
27624 Py_INCREF(Py_None); resultobj = Py_None;
27625 return resultobj;
27626 fail:
27627 return NULL;
27628 }
27629
27630
27631 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27632 PyObject *resultobj = NULL;
27633 wxWindow *arg1 = (wxWindow *) 0 ;
27634 wxSize *arg2 = 0 ;
27635 wxSize const &arg3_defvalue = wxDefaultSize ;
27636 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27637 wxSize const &arg4_defvalue = wxDefaultSize ;
27638 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27639 wxSize temp2 ;
27640 wxSize temp3 ;
27641 wxSize temp4 ;
27642 PyObject * obj0 = 0 ;
27643 PyObject * obj1 = 0 ;
27644 PyObject * obj2 = 0 ;
27645 PyObject * obj3 = 0 ;
27646 char *kwnames[] = {
27647 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27648 };
27649
27650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27652 if (SWIG_arg_fail(1)) SWIG_fail;
27653 {
27654 arg2 = &temp2;
27655 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27656 }
27657 if (obj2) {
27658 {
27659 arg3 = &temp3;
27660 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27661 }
27662 }
27663 if (obj3) {
27664 {
27665 arg4 = &temp4;
27666 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27667 }
27668 }
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27672
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 Py_INCREF(Py_None); resultobj = Py_None;
27677 return resultobj;
27678 fail:
27679 return NULL;
27680 }
27681
27682
27683 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27684 PyObject *resultobj = NULL;
27685 wxWindow *arg1 = (wxWindow *) 0 ;
27686 int arg2 ;
27687 int arg3 ;
27688 int arg4 = (int) -1 ;
27689 int arg5 = (int) -1 ;
27690 PyObject * obj0 = 0 ;
27691 PyObject * obj1 = 0 ;
27692 PyObject * obj2 = 0 ;
27693 PyObject * obj3 = 0 ;
27694 PyObject * obj4 = 0 ;
27695 char *kwnames[] = {
27696 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27697 };
27698
27699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27701 if (SWIG_arg_fail(1)) SWIG_fail;
27702 {
27703 arg2 = static_cast<int >(SWIG_As_int(obj1));
27704 if (SWIG_arg_fail(2)) SWIG_fail;
27705 }
27706 {
27707 arg3 = static_cast<int >(SWIG_As_int(obj2));
27708 if (SWIG_arg_fail(3)) SWIG_fail;
27709 }
27710 if (obj3) {
27711 {
27712 arg4 = static_cast<int >(SWIG_As_int(obj3));
27713 if (SWIG_arg_fail(4)) SWIG_fail;
27714 }
27715 }
27716 if (obj4) {
27717 {
27718 arg5 = static_cast<int >(SWIG_As_int(obj4));
27719 if (SWIG_arg_fail(5)) SWIG_fail;
27720 }
27721 }
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27725
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 Py_INCREF(Py_None); resultobj = Py_None;
27730 return resultobj;
27731 fail:
27732 return NULL;
27733 }
27734
27735
27736 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27737 PyObject *resultobj = NULL;
27738 wxWindow *arg1 = (wxWindow *) 0 ;
27739 wxSize *arg2 = 0 ;
27740 wxSize const &arg3_defvalue = wxDefaultSize ;
27741 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27742 wxSize temp2 ;
27743 wxSize temp3 ;
27744 PyObject * obj0 = 0 ;
27745 PyObject * obj1 = 0 ;
27746 PyObject * obj2 = 0 ;
27747 char *kwnames[] = {
27748 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27749 };
27750
27751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27753 if (SWIG_arg_fail(1)) SWIG_fail;
27754 {
27755 arg2 = &temp2;
27756 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27757 }
27758 if (obj2) {
27759 {
27760 arg3 = &temp3;
27761 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27762 }
27763 }
27764 {
27765 PyThreadState* __tstate = wxPyBeginAllowThreads();
27766 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27767
27768 wxPyEndAllowThreads(__tstate);
27769 if (PyErr_Occurred()) SWIG_fail;
27770 }
27771 Py_INCREF(Py_None); resultobj = Py_None;
27772 return resultobj;
27773 fail:
27774 return NULL;
27775 }
27776
27777
27778 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27779 PyObject *resultobj = NULL;
27780 wxWindow *arg1 = (wxWindow *) 0 ;
27781 wxSize result;
27782 PyObject * obj0 = 0 ;
27783 char *kwnames[] = {
27784 (char *) "self", NULL
27785 };
27786
27787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27789 if (SWIG_arg_fail(1)) SWIG_fail;
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 result = ((wxWindow const *)arg1)->GetMaxSize();
27793
27794 wxPyEndAllowThreads(__tstate);
27795 if (PyErr_Occurred()) SWIG_fail;
27796 }
27797 {
27798 wxSize * resultptr;
27799 resultptr = new wxSize(static_cast<wxSize & >(result));
27800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27801 }
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27809 PyObject *resultobj = NULL;
27810 wxWindow *arg1 = (wxWindow *) 0 ;
27811 wxSize result;
27812 PyObject * obj0 = 0 ;
27813 char *kwnames[] = {
27814 (char *) "self", NULL
27815 };
27816
27817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27819 if (SWIG_arg_fail(1)) SWIG_fail;
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 result = ((wxWindow const *)arg1)->GetMinSize();
27823
27824 wxPyEndAllowThreads(__tstate);
27825 if (PyErr_Occurred()) SWIG_fail;
27826 }
27827 {
27828 wxSize * resultptr;
27829 resultptr = new wxSize(static_cast<wxSize & >(result));
27830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27831 }
27832 return resultobj;
27833 fail:
27834 return NULL;
27835 }
27836
27837
27838 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27839 PyObject *resultobj = NULL;
27840 wxWindow *arg1 = (wxWindow *) 0 ;
27841 wxSize *arg2 = 0 ;
27842 wxSize temp2 ;
27843 PyObject * obj0 = 0 ;
27844 PyObject * obj1 = 0 ;
27845 char *kwnames[] = {
27846 (char *) "self",(char *) "minSize", NULL
27847 };
27848
27849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27851 if (SWIG_arg_fail(1)) SWIG_fail;
27852 {
27853 arg2 = &temp2;
27854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27855 }
27856 {
27857 PyThreadState* __tstate = wxPyBeginAllowThreads();
27858 (arg1)->SetMinSize((wxSize const &)*arg2);
27859
27860 wxPyEndAllowThreads(__tstate);
27861 if (PyErr_Occurred()) SWIG_fail;
27862 }
27863 Py_INCREF(Py_None); resultobj = Py_None;
27864 return resultobj;
27865 fail:
27866 return NULL;
27867 }
27868
27869
27870 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27871 PyObject *resultobj = NULL;
27872 wxWindow *arg1 = (wxWindow *) 0 ;
27873 wxSize *arg2 = 0 ;
27874 wxSize temp2 ;
27875 PyObject * obj0 = 0 ;
27876 PyObject * obj1 = 0 ;
27877 char *kwnames[] = {
27878 (char *) "self",(char *) "maxSize", NULL
27879 };
27880
27881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27883 if (SWIG_arg_fail(1)) SWIG_fail;
27884 {
27885 arg2 = &temp2;
27886 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27887 }
27888 {
27889 PyThreadState* __tstate = wxPyBeginAllowThreads();
27890 (arg1)->SetMaxSize((wxSize const &)*arg2);
27891
27892 wxPyEndAllowThreads(__tstate);
27893 if (PyErr_Occurred()) SWIG_fail;
27894 }
27895 Py_INCREF(Py_None); resultobj = Py_None;
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27903 PyObject *resultobj = NULL;
27904 wxWindow *arg1 = (wxWindow *) 0 ;
27905 int result;
27906 PyObject * obj0 = 0 ;
27907 char *kwnames[] = {
27908 (char *) "self", NULL
27909 };
27910
27911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27913 if (SWIG_arg_fail(1)) SWIG_fail;
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27917
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 {
27922 resultobj = SWIG_From_int(static_cast<int >(result));
27923 }
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27931 PyObject *resultobj = NULL;
27932 wxWindow *arg1 = (wxWindow *) 0 ;
27933 int result;
27934 PyObject * obj0 = 0 ;
27935 char *kwnames[] = {
27936 (char *) "self", NULL
27937 };
27938
27939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27941 if (SWIG_arg_fail(1)) SWIG_fail;
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27945
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 {
27950 resultobj = SWIG_From_int(static_cast<int >(result));
27951 }
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27959 PyObject *resultobj = NULL;
27960 wxWindow *arg1 = (wxWindow *) 0 ;
27961 int result;
27962 PyObject * obj0 = 0 ;
27963 char *kwnames[] = {
27964 (char *) "self", NULL
27965 };
27966
27967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27969 if (SWIG_arg_fail(1)) SWIG_fail;
27970 {
27971 PyThreadState* __tstate = wxPyBeginAllowThreads();
27972 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27973
27974 wxPyEndAllowThreads(__tstate);
27975 if (PyErr_Occurred()) SWIG_fail;
27976 }
27977 {
27978 resultobj = SWIG_From_int(static_cast<int >(result));
27979 }
27980 return resultobj;
27981 fail:
27982 return NULL;
27983 }
27984
27985
27986 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27987 PyObject *resultobj = NULL;
27988 wxWindow *arg1 = (wxWindow *) 0 ;
27989 int result;
27990 PyObject * obj0 = 0 ;
27991 char *kwnames[] = {
27992 (char *) "self", NULL
27993 };
27994
27995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27997 if (SWIG_arg_fail(1)) SWIG_fail;
27998 {
27999 PyThreadState* __tstate = wxPyBeginAllowThreads();
28000 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
28001
28002 wxPyEndAllowThreads(__tstate);
28003 if (PyErr_Occurred()) SWIG_fail;
28004 }
28005 {
28006 resultobj = SWIG_From_int(static_cast<int >(result));
28007 }
28008 return resultobj;
28009 fail:
28010 return NULL;
28011 }
28012
28013
28014 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28015 PyObject *resultobj = NULL;
28016 wxWindow *arg1 = (wxWindow *) 0 ;
28017 wxSize *arg2 = 0 ;
28018 wxSize temp2 ;
28019 PyObject * obj0 = 0 ;
28020 PyObject * obj1 = 0 ;
28021 char *kwnames[] = {
28022 (char *) "self",(char *) "size", NULL
28023 };
28024
28025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
28026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28027 if (SWIG_arg_fail(1)) SWIG_fail;
28028 {
28029 arg2 = &temp2;
28030 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28031 }
28032 {
28033 PyThreadState* __tstate = wxPyBeginAllowThreads();
28034 (arg1)->SetVirtualSize((wxSize const &)*arg2);
28035
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 Py_INCREF(Py_None); resultobj = Py_None;
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = NULL;
28048 wxWindow *arg1 = (wxWindow *) 0 ;
28049 int arg2 ;
28050 int arg3 ;
28051 PyObject * obj0 = 0 ;
28052 PyObject * obj1 = 0 ;
28053 PyObject * obj2 = 0 ;
28054 char *kwnames[] = {
28055 (char *) "self",(char *) "w",(char *) "h", NULL
28056 };
28057
28058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28060 if (SWIG_arg_fail(1)) SWIG_fail;
28061 {
28062 arg2 = static_cast<int >(SWIG_As_int(obj1));
28063 if (SWIG_arg_fail(2)) SWIG_fail;
28064 }
28065 {
28066 arg3 = static_cast<int >(SWIG_As_int(obj2));
28067 if (SWIG_arg_fail(3)) SWIG_fail;
28068 }
28069 {
28070 PyThreadState* __tstate = wxPyBeginAllowThreads();
28071 (arg1)->SetVirtualSize(arg2,arg3);
28072
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 Py_INCREF(Py_None); resultobj = Py_None;
28077 return resultobj;
28078 fail:
28079 return NULL;
28080 }
28081
28082
28083 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28084 PyObject *resultobj = NULL;
28085 wxWindow *arg1 = (wxWindow *) 0 ;
28086 wxSize result;
28087 PyObject * obj0 = 0 ;
28088 char *kwnames[] = {
28089 (char *) "self", NULL
28090 };
28091
28092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28094 if (SWIG_arg_fail(1)) SWIG_fail;
28095 {
28096 PyThreadState* __tstate = wxPyBeginAllowThreads();
28097 result = ((wxWindow const *)arg1)->GetVirtualSize();
28098
28099 wxPyEndAllowThreads(__tstate);
28100 if (PyErr_Occurred()) SWIG_fail;
28101 }
28102 {
28103 wxSize * resultptr;
28104 resultptr = new wxSize(static_cast<wxSize & >(result));
28105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28106 }
28107 return resultobj;
28108 fail:
28109 return NULL;
28110 }
28111
28112
28113 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28114 PyObject *resultobj = NULL;
28115 wxWindow *arg1 = (wxWindow *) 0 ;
28116 int *arg2 = (int *) 0 ;
28117 int *arg3 = (int *) 0 ;
28118 int temp2 ;
28119 int res2 = 0 ;
28120 int temp3 ;
28121 int res3 = 0 ;
28122 PyObject * obj0 = 0 ;
28123 char *kwnames[] = {
28124 (char *) "self", NULL
28125 };
28126
28127 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28128 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28131 if (SWIG_arg_fail(1)) SWIG_fail;
28132 {
28133 PyThreadState* __tstate = wxPyBeginAllowThreads();
28134 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28135
28136 wxPyEndAllowThreads(__tstate);
28137 if (PyErr_Occurred()) SWIG_fail;
28138 }
28139 Py_INCREF(Py_None); resultobj = Py_None;
28140 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28141 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28142 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28143 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28144 return resultobj;
28145 fail:
28146 return NULL;
28147 }
28148
28149
28150 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28151 PyObject *resultobj = NULL;
28152 wxWindow *arg1 = (wxWindow *) 0 ;
28153 wxSize result;
28154 PyObject * obj0 = 0 ;
28155 char *kwnames[] = {
28156 (char *) "self", NULL
28157 };
28158
28159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28161 if (SWIG_arg_fail(1)) SWIG_fail;
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 {
28170 wxSize * resultptr;
28171 resultptr = new wxSize(static_cast<wxSize & >(result));
28172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28173 }
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28181 PyObject *resultobj = NULL;
28182 wxWindow *arg1 = (wxWindow *) 0 ;
28183 bool arg2 = (bool) true ;
28184 bool result;
28185 PyObject * obj0 = 0 ;
28186 PyObject * obj1 = 0 ;
28187 char *kwnames[] = {
28188 (char *) "self",(char *) "show", NULL
28189 };
28190
28191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28193 if (SWIG_arg_fail(1)) SWIG_fail;
28194 if (obj1) {
28195 {
28196 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28197 if (SWIG_arg_fail(2)) SWIG_fail;
28198 }
28199 }
28200 {
28201 PyThreadState* __tstate = wxPyBeginAllowThreads();
28202 result = (bool)(arg1)->Show(arg2);
28203
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 {
28208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28209 }
28210 return resultobj;
28211 fail:
28212 return NULL;
28213 }
28214
28215
28216 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28217 PyObject *resultobj = NULL;
28218 wxWindow *arg1 = (wxWindow *) 0 ;
28219 bool result;
28220 PyObject * obj0 = 0 ;
28221 char *kwnames[] = {
28222 (char *) "self", NULL
28223 };
28224
28225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",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 result = (bool)(arg1)->Hide();
28231
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 {
28236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28237 }
28238 return resultobj;
28239 fail:
28240 return NULL;
28241 }
28242
28243
28244 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28245 PyObject *resultobj = NULL;
28246 wxWindow *arg1 = (wxWindow *) 0 ;
28247 bool arg2 = (bool) true ;
28248 bool result;
28249 PyObject * obj0 = 0 ;
28250 PyObject * obj1 = 0 ;
28251 char *kwnames[] = {
28252 (char *) "self",(char *) "enable", NULL
28253 };
28254
28255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) 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 if (obj1) {
28259 {
28260 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28261 if (SWIG_arg_fail(2)) SWIG_fail;
28262 }
28263 }
28264 {
28265 PyThreadState* __tstate = wxPyBeginAllowThreads();
28266 result = (bool)(arg1)->Enable(arg2);
28267
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 {
28272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28273 }
28274 return resultobj;
28275 fail:
28276 return NULL;
28277 }
28278
28279
28280 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28281 PyObject *resultobj = NULL;
28282 wxWindow *arg1 = (wxWindow *) 0 ;
28283 bool result;
28284 PyObject * obj0 = 0 ;
28285 char *kwnames[] = {
28286 (char *) "self", NULL
28287 };
28288
28289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28291 if (SWIG_arg_fail(1)) SWIG_fail;
28292 {
28293 PyThreadState* __tstate = wxPyBeginAllowThreads();
28294 result = (bool)(arg1)->Disable();
28295
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 {
28300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28301 }
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28309 PyObject *resultobj = NULL;
28310 wxWindow *arg1 = (wxWindow *) 0 ;
28311 bool result;
28312 PyObject * obj0 = 0 ;
28313 char *kwnames[] = {
28314 (char *) "self", NULL
28315 };
28316
28317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28319 if (SWIG_arg_fail(1)) SWIG_fail;
28320 {
28321 PyThreadState* __tstate = wxPyBeginAllowThreads();
28322 result = (bool)((wxWindow const *)arg1)->IsShown();
28323
28324 wxPyEndAllowThreads(__tstate);
28325 if (PyErr_Occurred()) SWIG_fail;
28326 }
28327 {
28328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28329 }
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28337 PyObject *resultobj = NULL;
28338 wxWindow *arg1 = (wxWindow *) 0 ;
28339 bool result;
28340 PyObject * obj0 = 0 ;
28341 char *kwnames[] = {
28342 (char *) "self", NULL
28343 };
28344
28345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28347 if (SWIG_arg_fail(1)) SWIG_fail;
28348 {
28349 PyThreadState* __tstate = wxPyBeginAllowThreads();
28350 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28351
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 {
28356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28357 }
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = NULL;
28366 wxWindow *arg1 = (wxWindow *) 0 ;
28367 long arg2 ;
28368 PyObject * obj0 = 0 ;
28369 PyObject * obj1 = 0 ;
28370 char *kwnames[] = {
28371 (char *) "self",(char *) "style", NULL
28372 };
28373
28374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28376 if (SWIG_arg_fail(1)) SWIG_fail;
28377 {
28378 arg2 = static_cast<long >(SWIG_As_long(obj1));
28379 if (SWIG_arg_fail(2)) SWIG_fail;
28380 }
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 (arg1)->SetWindowStyleFlag(arg2);
28384
28385 wxPyEndAllowThreads(__tstate);
28386 if (PyErr_Occurred()) SWIG_fail;
28387 }
28388 Py_INCREF(Py_None); resultobj = Py_None;
28389 return resultobj;
28390 fail:
28391 return NULL;
28392 }
28393
28394
28395 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28396 PyObject *resultobj = NULL;
28397 wxWindow *arg1 = (wxWindow *) 0 ;
28398 long result;
28399 PyObject * obj0 = 0 ;
28400 char *kwnames[] = {
28401 (char *) "self", NULL
28402 };
28403
28404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28406 if (SWIG_arg_fail(1)) SWIG_fail;
28407 {
28408 PyThreadState* __tstate = wxPyBeginAllowThreads();
28409 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28410
28411 wxPyEndAllowThreads(__tstate);
28412 if (PyErr_Occurred()) SWIG_fail;
28413 }
28414 {
28415 resultobj = SWIG_From_long(static_cast<long >(result));
28416 }
28417 return resultobj;
28418 fail:
28419 return NULL;
28420 }
28421
28422
28423 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28424 PyObject *resultobj = NULL;
28425 wxWindow *arg1 = (wxWindow *) 0 ;
28426 int arg2 ;
28427 bool result;
28428 PyObject * obj0 = 0 ;
28429 PyObject * obj1 = 0 ;
28430 char *kwnames[] = {
28431 (char *) "self",(char *) "flag", NULL
28432 };
28433
28434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28436 if (SWIG_arg_fail(1)) SWIG_fail;
28437 {
28438 arg2 = static_cast<int >(SWIG_As_int(obj1));
28439 if (SWIG_arg_fail(2)) SWIG_fail;
28440 }
28441 {
28442 PyThreadState* __tstate = wxPyBeginAllowThreads();
28443 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28444
28445 wxPyEndAllowThreads(__tstate);
28446 if (PyErr_Occurred()) SWIG_fail;
28447 }
28448 {
28449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28450 }
28451 return resultobj;
28452 fail:
28453 return NULL;
28454 }
28455
28456
28457 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28458 PyObject *resultobj = NULL;
28459 wxWindow *arg1 = (wxWindow *) 0 ;
28460 bool result;
28461 PyObject * obj0 = 0 ;
28462 char *kwnames[] = {
28463 (char *) "self", NULL
28464 };
28465
28466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28468 if (SWIG_arg_fail(1)) SWIG_fail;
28469 {
28470 PyThreadState* __tstate = wxPyBeginAllowThreads();
28471 result = (bool)((wxWindow const *)arg1)->IsRetained();
28472
28473 wxPyEndAllowThreads(__tstate);
28474 if (PyErr_Occurred()) SWIG_fail;
28475 }
28476 {
28477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28478 }
28479 return resultobj;
28480 fail:
28481 return NULL;
28482 }
28483
28484
28485 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28486 PyObject *resultobj = NULL;
28487 wxWindow *arg1 = (wxWindow *) 0 ;
28488 long arg2 ;
28489 PyObject * obj0 = 0 ;
28490 PyObject * obj1 = 0 ;
28491 char *kwnames[] = {
28492 (char *) "self",(char *) "exStyle", NULL
28493 };
28494
28495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28497 if (SWIG_arg_fail(1)) SWIG_fail;
28498 {
28499 arg2 = static_cast<long >(SWIG_As_long(obj1));
28500 if (SWIG_arg_fail(2)) SWIG_fail;
28501 }
28502 {
28503 PyThreadState* __tstate = wxPyBeginAllowThreads();
28504 (arg1)->SetExtraStyle(arg2);
28505
28506 wxPyEndAllowThreads(__tstate);
28507 if (PyErr_Occurred()) SWIG_fail;
28508 }
28509 Py_INCREF(Py_None); resultobj = Py_None;
28510 return resultobj;
28511 fail:
28512 return NULL;
28513 }
28514
28515
28516 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28517 PyObject *resultobj = NULL;
28518 wxWindow *arg1 = (wxWindow *) 0 ;
28519 long result;
28520 PyObject * obj0 = 0 ;
28521 char *kwnames[] = {
28522 (char *) "self", NULL
28523 };
28524
28525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28527 if (SWIG_arg_fail(1)) SWIG_fail;
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28531
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 {
28536 resultobj = SWIG_From_long(static_cast<long >(result));
28537 }
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj = NULL;
28546 wxWindow *arg1 = (wxWindow *) 0 ;
28547 bool arg2 = (bool) true ;
28548 PyObject * obj0 = 0 ;
28549 PyObject * obj1 = 0 ;
28550 char *kwnames[] = {
28551 (char *) "self",(char *) "modal", NULL
28552 };
28553
28554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28556 if (SWIG_arg_fail(1)) SWIG_fail;
28557 if (obj1) {
28558 {
28559 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28560 if (SWIG_arg_fail(2)) SWIG_fail;
28561 }
28562 }
28563 {
28564 PyThreadState* __tstate = wxPyBeginAllowThreads();
28565 (arg1)->MakeModal(arg2);
28566
28567 wxPyEndAllowThreads(__tstate);
28568 if (PyErr_Occurred()) SWIG_fail;
28569 }
28570 Py_INCREF(Py_None); resultobj = Py_None;
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28578 PyObject *resultobj = NULL;
28579 wxWindow *arg1 = (wxWindow *) 0 ;
28580 bool arg2 ;
28581 PyObject * obj0 = 0 ;
28582 PyObject * obj1 = 0 ;
28583 char *kwnames[] = {
28584 (char *) "self",(char *) "enableTheme", NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28589 if (SWIG_arg_fail(1)) SWIG_fail;
28590 {
28591 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28592 if (SWIG_arg_fail(2)) SWIG_fail;
28593 }
28594 {
28595 PyThreadState* __tstate = wxPyBeginAllowThreads();
28596 (arg1)->SetThemeEnabled(arg2);
28597
28598 wxPyEndAllowThreads(__tstate);
28599 if (PyErr_Occurred()) SWIG_fail;
28600 }
28601 Py_INCREF(Py_None); resultobj = Py_None;
28602 return resultobj;
28603 fail:
28604 return NULL;
28605 }
28606
28607
28608 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28609 PyObject *resultobj = NULL;
28610 wxWindow *arg1 = (wxWindow *) 0 ;
28611 bool result;
28612 PyObject * obj0 = 0 ;
28613 char *kwnames[] = {
28614 (char *) "self", NULL
28615 };
28616
28617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28619 if (SWIG_arg_fail(1)) SWIG_fail;
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28623
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 {
28628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28629 }
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28637 PyObject *resultobj = NULL;
28638 wxWindow *arg1 = (wxWindow *) 0 ;
28639 PyObject * obj0 = 0 ;
28640 char *kwnames[] = {
28641 (char *) "self", NULL
28642 };
28643
28644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28646 if (SWIG_arg_fail(1)) SWIG_fail;
28647 {
28648 PyThreadState* __tstate = wxPyBeginAllowThreads();
28649 (arg1)->SetFocus();
28650
28651 wxPyEndAllowThreads(__tstate);
28652 if (PyErr_Occurred()) SWIG_fail;
28653 }
28654 Py_INCREF(Py_None); resultobj = Py_None;
28655 return resultobj;
28656 fail:
28657 return NULL;
28658 }
28659
28660
28661 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28662 PyObject *resultobj = NULL;
28663 wxWindow *arg1 = (wxWindow *) 0 ;
28664 PyObject * obj0 = 0 ;
28665 char *kwnames[] = {
28666 (char *) "self", NULL
28667 };
28668
28669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28671 if (SWIG_arg_fail(1)) SWIG_fail;
28672 {
28673 PyThreadState* __tstate = wxPyBeginAllowThreads();
28674 (arg1)->SetFocusFromKbd();
28675
28676 wxPyEndAllowThreads(__tstate);
28677 if (PyErr_Occurred()) SWIG_fail;
28678 }
28679 Py_INCREF(Py_None); resultobj = Py_None;
28680 return resultobj;
28681 fail:
28682 return NULL;
28683 }
28684
28685
28686 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28687 PyObject *resultobj = NULL;
28688 wxWindow *result;
28689 char *kwnames[] = {
28690 NULL
28691 };
28692
28693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28694 {
28695 if (!wxPyCheckForApp()) SWIG_fail;
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 result = (wxWindow *)wxWindow::FindFocus();
28698
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 {
28703 resultobj = wxPyMake_wxObject(result, 0);
28704 }
28705 return resultobj;
28706 fail:
28707 return NULL;
28708 }
28709
28710
28711 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28712 PyObject *resultobj = NULL;
28713 wxWindow *arg1 = (wxWindow *) 0 ;
28714 bool result;
28715 PyObject * obj0 = 0 ;
28716 char *kwnames[] = {
28717 (char *) "self", NULL
28718 };
28719
28720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28722 if (SWIG_arg_fail(1)) SWIG_fail;
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28726
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 {
28731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28732 }
28733 return resultobj;
28734 fail:
28735 return NULL;
28736 }
28737
28738
28739 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28740 PyObject *resultobj = NULL;
28741 wxWindow *arg1 = (wxWindow *) 0 ;
28742 bool result;
28743 PyObject * obj0 = 0 ;
28744 char *kwnames[] = {
28745 (char *) "self", NULL
28746 };
28747
28748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28750 if (SWIG_arg_fail(1)) SWIG_fail;
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28754
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 {
28759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28760 }
28761 return resultobj;
28762 fail:
28763 return NULL;
28764 }
28765
28766
28767 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28768 PyObject *resultobj = NULL;
28769 wxWindow *arg1 = (wxWindow *) 0 ;
28770 wxWindow *result;
28771 PyObject * obj0 = 0 ;
28772 char *kwnames[] = {
28773 (char *) "self", NULL
28774 };
28775
28776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28778 if (SWIG_arg_fail(1)) SWIG_fail;
28779 {
28780 PyThreadState* __tstate = wxPyBeginAllowThreads();
28781 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28782
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 {
28787 resultobj = wxPyMake_wxObject(result, 0);
28788 }
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28796 PyObject *resultobj = NULL;
28797 wxWindow *arg1 = (wxWindow *) 0 ;
28798 wxWindow *arg2 = (wxWindow *) 0 ;
28799 wxWindow *result;
28800 PyObject * obj0 = 0 ;
28801 PyObject * obj1 = 0 ;
28802 char *kwnames[] = {
28803 (char *) "self",(char *) "child", NULL
28804 };
28805
28806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28808 if (SWIG_arg_fail(1)) SWIG_fail;
28809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28810 if (SWIG_arg_fail(2)) SWIG_fail;
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28814
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 {
28819 resultobj = wxPyMake_wxObject(result, 0);
28820 }
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28828 PyObject *resultobj = NULL;
28829 wxWindow *arg1 = (wxWindow *) 0 ;
28830 wxWindow *arg2 = (wxWindow *) 0 ;
28831 PyObject * obj0 = 0 ;
28832 PyObject * obj1 = 0 ;
28833 char *kwnames[] = {
28834 (char *) "self",(char *) "win", NULL
28835 };
28836
28837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28839 if (SWIG_arg_fail(1)) SWIG_fail;
28840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28841 if (SWIG_arg_fail(2)) SWIG_fail;
28842 {
28843 PyThreadState* __tstate = wxPyBeginAllowThreads();
28844 (arg1)->SetTmpDefaultItem(arg2);
28845
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 Py_INCREF(Py_None); resultobj = Py_None;
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28857 PyObject *resultobj = NULL;
28858 wxWindow *arg1 = (wxWindow *) 0 ;
28859 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28860 bool result;
28861 PyObject * obj0 = 0 ;
28862 PyObject * obj1 = 0 ;
28863 char *kwnames[] = {
28864 (char *) "self",(char *) "flags", NULL
28865 };
28866
28867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28869 if (SWIG_arg_fail(1)) SWIG_fail;
28870 if (obj1) {
28871 {
28872 arg2 = static_cast<int >(SWIG_As_int(obj1));
28873 if (SWIG_arg_fail(2)) SWIG_fail;
28874 }
28875 }
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 result = (bool)(arg1)->Navigate(arg2);
28879
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 {
28884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28885 }
28886 return resultobj;
28887 fail:
28888 return NULL;
28889 }
28890
28891
28892 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28893 PyObject *resultobj = NULL;
28894 wxWindow *arg1 = (wxWindow *) 0 ;
28895 wxWindow *arg2 = (wxWindow *) 0 ;
28896 PyObject * obj0 = 0 ;
28897 PyObject * obj1 = 0 ;
28898 char *kwnames[] = {
28899 (char *) "self",(char *) "win", NULL
28900 };
28901
28902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",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 (arg1)->MoveAfterInTabOrder(arg2);
28910
28911 wxPyEndAllowThreads(__tstate);
28912 if (PyErr_Occurred()) SWIG_fail;
28913 }
28914 Py_INCREF(Py_None); resultobj = Py_None;
28915 return resultobj;
28916 fail:
28917 return NULL;
28918 }
28919
28920
28921 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28922 PyObject *resultobj = NULL;
28923 wxWindow *arg1 = (wxWindow *) 0 ;
28924 wxWindow *arg2 = (wxWindow *) 0 ;
28925 PyObject * obj0 = 0 ;
28926 PyObject * obj1 = 0 ;
28927 char *kwnames[] = {
28928 (char *) "self",(char *) "win", NULL
28929 };
28930
28931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28933 if (SWIG_arg_fail(1)) SWIG_fail;
28934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28935 if (SWIG_arg_fail(2)) SWIG_fail;
28936 {
28937 PyThreadState* __tstate = wxPyBeginAllowThreads();
28938 (arg1)->MoveBeforeInTabOrder(arg2);
28939
28940 wxPyEndAllowThreads(__tstate);
28941 if (PyErr_Occurred()) SWIG_fail;
28942 }
28943 Py_INCREF(Py_None); resultobj = Py_None;
28944 return resultobj;
28945 fail:
28946 return NULL;
28947 }
28948
28949
28950 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28951 PyObject *resultobj = NULL;
28952 wxWindow *arg1 = (wxWindow *) 0 ;
28953 PyObject *result;
28954 PyObject * obj0 = 0 ;
28955 char *kwnames[] = {
28956 (char *) "self", NULL
28957 };
28958
28959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28961 if (SWIG_arg_fail(1)) SWIG_fail;
28962 {
28963 PyThreadState* __tstate = wxPyBeginAllowThreads();
28964 result = (PyObject *)wxWindow_GetChildren(arg1);
28965
28966 wxPyEndAllowThreads(__tstate);
28967 if (PyErr_Occurred()) SWIG_fail;
28968 }
28969 resultobj = result;
28970 return resultobj;
28971 fail:
28972 return NULL;
28973 }
28974
28975
28976 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28977 PyObject *resultobj = NULL;
28978 wxWindow *arg1 = (wxWindow *) 0 ;
28979 wxWindow *result;
28980 PyObject * obj0 = 0 ;
28981 char *kwnames[] = {
28982 (char *) "self", NULL
28983 };
28984
28985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28987 if (SWIG_arg_fail(1)) SWIG_fail;
28988 {
28989 PyThreadState* __tstate = wxPyBeginAllowThreads();
28990 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28991
28992 wxPyEndAllowThreads(__tstate);
28993 if (PyErr_Occurred()) SWIG_fail;
28994 }
28995 {
28996 resultobj = wxPyMake_wxObject(result, 0);
28997 }
28998 return resultobj;
28999 fail:
29000 return NULL;
29001 }
29002
29003
29004 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
29005 PyObject *resultobj = NULL;
29006 wxWindow *arg1 = (wxWindow *) 0 ;
29007 wxWindow *result;
29008 PyObject * obj0 = 0 ;
29009 char *kwnames[] = {
29010 (char *) "self", NULL
29011 };
29012
29013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
29014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29015 if (SWIG_arg_fail(1)) SWIG_fail;
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
29019
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 {
29024 resultobj = wxPyMake_wxObject(result, 0);
29025 }
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj = NULL;
29034 wxWindow *arg1 = (wxWindow *) 0 ;
29035 bool result;
29036 PyObject * obj0 = 0 ;
29037 char *kwnames[] = {
29038 (char *) "self", NULL
29039 };
29040
29041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
29042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29043 if (SWIG_arg_fail(1)) SWIG_fail;
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 {
29052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29053 }
29054 return resultobj;
29055 fail:
29056 return NULL;
29057 }
29058
29059
29060 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29061 PyObject *resultobj = NULL;
29062 wxWindow *arg1 = (wxWindow *) 0 ;
29063 wxWindow *arg2 = (wxWindow *) 0 ;
29064 bool result;
29065 PyObject * obj0 = 0 ;
29066 PyObject * obj1 = 0 ;
29067 char *kwnames[] = {
29068 (char *) "self",(char *) "newParent", NULL
29069 };
29070
29071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29073 if (SWIG_arg_fail(1)) SWIG_fail;
29074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29075 if (SWIG_arg_fail(2)) SWIG_fail;
29076 {
29077 PyThreadState* __tstate = wxPyBeginAllowThreads();
29078 result = (bool)(arg1)->Reparent(arg2);
29079
29080 wxPyEndAllowThreads(__tstate);
29081 if (PyErr_Occurred()) SWIG_fail;
29082 }
29083 {
29084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29085 }
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29093 PyObject *resultobj = NULL;
29094 wxWindow *arg1 = (wxWindow *) 0 ;
29095 wxWindow *arg2 = (wxWindow *) 0 ;
29096 PyObject * obj0 = 0 ;
29097 PyObject * obj1 = 0 ;
29098 char *kwnames[] = {
29099 (char *) "self",(char *) "child", NULL
29100 };
29101
29102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29104 if (SWIG_arg_fail(1)) SWIG_fail;
29105 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29106 if (SWIG_arg_fail(2)) SWIG_fail;
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 (arg1)->AddChild(arg2);
29110
29111 wxPyEndAllowThreads(__tstate);
29112 if (PyErr_Occurred()) SWIG_fail;
29113 }
29114 Py_INCREF(Py_None); resultobj = Py_None;
29115 return resultobj;
29116 fail:
29117 return NULL;
29118 }
29119
29120
29121 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29122 PyObject *resultobj = NULL;
29123 wxWindow *arg1 = (wxWindow *) 0 ;
29124 wxWindow *arg2 = (wxWindow *) 0 ;
29125 PyObject * obj0 = 0 ;
29126 PyObject * obj1 = 0 ;
29127 char *kwnames[] = {
29128 (char *) "self",(char *) "child", NULL
29129 };
29130
29131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29133 if (SWIG_arg_fail(1)) SWIG_fail;
29134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29135 if (SWIG_arg_fail(2)) SWIG_fail;
29136 {
29137 PyThreadState* __tstate = wxPyBeginAllowThreads();
29138 (arg1)->RemoveChild(arg2);
29139
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 Py_INCREF(Py_None); resultobj = Py_None;
29144 return resultobj;
29145 fail:
29146 return NULL;
29147 }
29148
29149
29150 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29151 PyObject *resultobj = NULL;
29152 wxWindow *arg1 = (wxWindow *) 0 ;
29153 long arg2 ;
29154 wxWindow *result;
29155 PyObject * obj0 = 0 ;
29156 PyObject * obj1 = 0 ;
29157 char *kwnames[] = {
29158 (char *) "self",(char *) "winid", NULL
29159 };
29160
29161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29163 if (SWIG_arg_fail(1)) SWIG_fail;
29164 {
29165 arg2 = static_cast<long >(SWIG_As_long(obj1));
29166 if (SWIG_arg_fail(2)) SWIG_fail;
29167 }
29168 {
29169 PyThreadState* __tstate = wxPyBeginAllowThreads();
29170 result = (wxWindow *)(arg1)->FindWindow(arg2);
29171
29172 wxPyEndAllowThreads(__tstate);
29173 if (PyErr_Occurred()) SWIG_fail;
29174 }
29175 {
29176 resultobj = wxPyMake_wxObject(result, 0);
29177 }
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29185 PyObject *resultobj = NULL;
29186 wxWindow *arg1 = (wxWindow *) 0 ;
29187 wxString *arg2 = 0 ;
29188 wxWindow *result;
29189 bool temp2 = false ;
29190 PyObject * obj0 = 0 ;
29191 PyObject * obj1 = 0 ;
29192 char *kwnames[] = {
29193 (char *) "self",(char *) "name", NULL
29194 };
29195
29196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29198 if (SWIG_arg_fail(1)) SWIG_fail;
29199 {
29200 arg2 = wxString_in_helper(obj1);
29201 if (arg2 == NULL) SWIG_fail;
29202 temp2 = true;
29203 }
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29207
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 {
29212 resultobj = wxPyMake_wxObject(result, 0);
29213 }
29214 {
29215 if (temp2)
29216 delete arg2;
29217 }
29218 return resultobj;
29219 fail:
29220 {
29221 if (temp2)
29222 delete arg2;
29223 }
29224 return NULL;
29225 }
29226
29227
29228 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29229 PyObject *resultobj = NULL;
29230 wxWindow *arg1 = (wxWindow *) 0 ;
29231 wxEvtHandler *result;
29232 PyObject * obj0 = 0 ;
29233 char *kwnames[] = {
29234 (char *) "self", NULL
29235 };
29236
29237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29239 if (SWIG_arg_fail(1)) SWIG_fail;
29240 {
29241 PyThreadState* __tstate = wxPyBeginAllowThreads();
29242 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29243
29244 wxPyEndAllowThreads(__tstate);
29245 if (PyErr_Occurred()) SWIG_fail;
29246 }
29247 {
29248 resultobj = wxPyMake_wxObject(result, 0);
29249 }
29250 return resultobj;
29251 fail:
29252 return NULL;
29253 }
29254
29255
29256 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29257 PyObject *resultobj = NULL;
29258 wxWindow *arg1 = (wxWindow *) 0 ;
29259 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29260 PyObject * obj0 = 0 ;
29261 PyObject * obj1 = 0 ;
29262 char *kwnames[] = {
29263 (char *) "self",(char *) "handler", NULL
29264 };
29265
29266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29268 if (SWIG_arg_fail(1)) SWIG_fail;
29269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29270 if (SWIG_arg_fail(2)) SWIG_fail;
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 (arg1)->SetEventHandler(arg2);
29274
29275 wxPyEndAllowThreads(__tstate);
29276 if (PyErr_Occurred()) SWIG_fail;
29277 }
29278 Py_INCREF(Py_None); resultobj = Py_None;
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29286 PyObject *resultobj = NULL;
29287 wxWindow *arg1 = (wxWindow *) 0 ;
29288 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29289 PyObject * obj0 = 0 ;
29290 PyObject * obj1 = 0 ;
29291 char *kwnames[] = {
29292 (char *) "self",(char *) "handler", NULL
29293 };
29294
29295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29297 if (SWIG_arg_fail(1)) SWIG_fail;
29298 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29299 if (SWIG_arg_fail(2)) SWIG_fail;
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 (arg1)->PushEventHandler(arg2);
29303
29304 wxPyEndAllowThreads(__tstate);
29305 if (PyErr_Occurred()) SWIG_fail;
29306 }
29307 Py_INCREF(Py_None); resultobj = Py_None;
29308 return resultobj;
29309 fail:
29310 return NULL;
29311 }
29312
29313
29314 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29315 PyObject *resultobj = NULL;
29316 wxWindow *arg1 = (wxWindow *) 0 ;
29317 bool arg2 = (bool) false ;
29318 wxEvtHandler *result;
29319 PyObject * obj0 = 0 ;
29320 PyObject * obj1 = 0 ;
29321 char *kwnames[] = {
29322 (char *) "self",(char *) "deleteHandler", NULL
29323 };
29324
29325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29327 if (SWIG_arg_fail(1)) SWIG_fail;
29328 if (obj1) {
29329 {
29330 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29331 if (SWIG_arg_fail(2)) SWIG_fail;
29332 }
29333 }
29334 {
29335 PyThreadState* __tstate = wxPyBeginAllowThreads();
29336 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29337
29338 wxPyEndAllowThreads(__tstate);
29339 if (PyErr_Occurred()) SWIG_fail;
29340 }
29341 {
29342 resultobj = wxPyMake_wxObject(result, 0);
29343 }
29344 return resultobj;
29345 fail:
29346 return NULL;
29347 }
29348
29349
29350 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29351 PyObject *resultobj = NULL;
29352 wxWindow *arg1 = (wxWindow *) 0 ;
29353 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29354 bool result;
29355 PyObject * obj0 = 0 ;
29356 PyObject * obj1 = 0 ;
29357 char *kwnames[] = {
29358 (char *) "self",(char *) "handler", NULL
29359 };
29360
29361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29363 if (SWIG_arg_fail(1)) SWIG_fail;
29364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29365 if (SWIG_arg_fail(2)) SWIG_fail;
29366 {
29367 PyThreadState* __tstate = wxPyBeginAllowThreads();
29368 result = (bool)(arg1)->RemoveEventHandler(arg2);
29369
29370 wxPyEndAllowThreads(__tstate);
29371 if (PyErr_Occurred()) SWIG_fail;
29372 }
29373 {
29374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29375 }
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29383 PyObject *resultobj = NULL;
29384 wxWindow *arg1 = (wxWindow *) 0 ;
29385 wxValidator *arg2 = 0 ;
29386 PyObject * obj0 = 0 ;
29387 PyObject * obj1 = 0 ;
29388 char *kwnames[] = {
29389 (char *) "self",(char *) "validator", NULL
29390 };
29391
29392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29394 if (SWIG_arg_fail(1)) SWIG_fail;
29395 {
29396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29397 if (SWIG_arg_fail(2)) SWIG_fail;
29398 if (arg2 == NULL) {
29399 SWIG_null_ref("wxValidator");
29400 }
29401 if (SWIG_arg_fail(2)) SWIG_fail;
29402 }
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 (arg1)->SetValidator((wxValidator const &)*arg2);
29406
29407 wxPyEndAllowThreads(__tstate);
29408 if (PyErr_Occurred()) SWIG_fail;
29409 }
29410 Py_INCREF(Py_None); resultobj = Py_None;
29411 return resultobj;
29412 fail:
29413 return NULL;
29414 }
29415
29416
29417 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29418 PyObject *resultobj = NULL;
29419 wxWindow *arg1 = (wxWindow *) 0 ;
29420 wxValidator *result;
29421 PyObject * obj0 = 0 ;
29422 char *kwnames[] = {
29423 (char *) "self", NULL
29424 };
29425
29426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29428 if (SWIG_arg_fail(1)) SWIG_fail;
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 result = (wxValidator *)(arg1)->GetValidator();
29432
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 {
29437 resultobj = wxPyMake_wxObject(result, (bool)0);
29438 }
29439 return resultobj;
29440 fail:
29441 return NULL;
29442 }
29443
29444
29445 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29446 PyObject *resultobj = NULL;
29447 wxWindow *arg1 = (wxWindow *) 0 ;
29448 bool result;
29449 PyObject * obj0 = 0 ;
29450 char *kwnames[] = {
29451 (char *) "self", NULL
29452 };
29453
29454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29456 if (SWIG_arg_fail(1)) SWIG_fail;
29457 {
29458 PyThreadState* __tstate = wxPyBeginAllowThreads();
29459 result = (bool)(arg1)->Validate();
29460
29461 wxPyEndAllowThreads(__tstate);
29462 if (PyErr_Occurred()) SWIG_fail;
29463 }
29464 {
29465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29466 }
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29474 PyObject *resultobj = NULL;
29475 wxWindow *arg1 = (wxWindow *) 0 ;
29476 bool result;
29477 PyObject * obj0 = 0 ;
29478 char *kwnames[] = {
29479 (char *) "self", NULL
29480 };
29481
29482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29484 if (SWIG_arg_fail(1)) SWIG_fail;
29485 {
29486 PyThreadState* __tstate = wxPyBeginAllowThreads();
29487 result = (bool)(arg1)->TransferDataToWindow();
29488
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 {
29493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29494 }
29495 return resultobj;
29496 fail:
29497 return NULL;
29498 }
29499
29500
29501 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29502 PyObject *resultobj = NULL;
29503 wxWindow *arg1 = (wxWindow *) 0 ;
29504 bool result;
29505 PyObject * obj0 = 0 ;
29506 char *kwnames[] = {
29507 (char *) "self", NULL
29508 };
29509
29510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29512 if (SWIG_arg_fail(1)) SWIG_fail;
29513 {
29514 PyThreadState* __tstate = wxPyBeginAllowThreads();
29515 result = (bool)(arg1)->TransferDataFromWindow();
29516
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 {
29521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29522 }
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj = NULL;
29531 wxWindow *arg1 = (wxWindow *) 0 ;
29532 PyObject * obj0 = 0 ;
29533 char *kwnames[] = {
29534 (char *) "self", NULL
29535 };
29536
29537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29539 if (SWIG_arg_fail(1)) SWIG_fail;
29540 {
29541 PyThreadState* __tstate = wxPyBeginAllowThreads();
29542 (arg1)->InitDialog();
29543
29544 wxPyEndAllowThreads(__tstate);
29545 if (PyErr_Occurred()) SWIG_fail;
29546 }
29547 Py_INCREF(Py_None); resultobj = Py_None;
29548 return resultobj;
29549 fail:
29550 return NULL;
29551 }
29552
29553
29554 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29555 PyObject *resultobj = NULL;
29556 wxWindow *arg1 = (wxWindow *) 0 ;
29557 wxAcceleratorTable *arg2 = 0 ;
29558 PyObject * obj0 = 0 ;
29559 PyObject * obj1 = 0 ;
29560 char *kwnames[] = {
29561 (char *) "self",(char *) "accel", NULL
29562 };
29563
29564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29566 if (SWIG_arg_fail(1)) SWIG_fail;
29567 {
29568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29569 if (SWIG_arg_fail(2)) SWIG_fail;
29570 if (arg2 == NULL) {
29571 SWIG_null_ref("wxAcceleratorTable");
29572 }
29573 if (SWIG_arg_fail(2)) SWIG_fail;
29574 }
29575 {
29576 PyThreadState* __tstate = wxPyBeginAllowThreads();
29577 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29578
29579 wxPyEndAllowThreads(__tstate);
29580 if (PyErr_Occurred()) SWIG_fail;
29581 }
29582 Py_INCREF(Py_None); resultobj = Py_None;
29583 return resultobj;
29584 fail:
29585 return NULL;
29586 }
29587
29588
29589 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29590 PyObject *resultobj = NULL;
29591 wxWindow *arg1 = (wxWindow *) 0 ;
29592 wxAcceleratorTable *result;
29593 PyObject * obj0 = 0 ;
29594 char *kwnames[] = {
29595 (char *) "self", NULL
29596 };
29597
29598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29600 if (SWIG_arg_fail(1)) SWIG_fail;
29601 {
29602 PyThreadState* __tstate = wxPyBeginAllowThreads();
29603 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29604
29605 wxPyEndAllowThreads(__tstate);
29606 if (PyErr_Occurred()) SWIG_fail;
29607 }
29608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29609 return resultobj;
29610 fail:
29611 return NULL;
29612 }
29613
29614
29615 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29616 PyObject *resultobj = NULL;
29617 wxWindow *arg1 = (wxWindow *) 0 ;
29618 int arg2 ;
29619 int arg3 ;
29620 int arg4 ;
29621 bool result;
29622 PyObject * obj0 = 0 ;
29623 PyObject * obj1 = 0 ;
29624 PyObject * obj2 = 0 ;
29625 PyObject * obj3 = 0 ;
29626 char *kwnames[] = {
29627 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29628 };
29629
29630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29632 if (SWIG_arg_fail(1)) SWIG_fail;
29633 {
29634 arg2 = static_cast<int >(SWIG_As_int(obj1));
29635 if (SWIG_arg_fail(2)) SWIG_fail;
29636 }
29637 {
29638 arg3 = static_cast<int >(SWIG_As_int(obj2));
29639 if (SWIG_arg_fail(3)) SWIG_fail;
29640 }
29641 {
29642 arg4 = static_cast<int >(SWIG_As_int(obj3));
29643 if (SWIG_arg_fail(4)) SWIG_fail;
29644 }
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29648
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 {
29653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29654 }
29655 return resultobj;
29656 fail:
29657 return NULL;
29658 }
29659
29660
29661 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29662 PyObject *resultobj = NULL;
29663 wxWindow *arg1 = (wxWindow *) 0 ;
29664 int arg2 ;
29665 bool result;
29666 PyObject * obj0 = 0 ;
29667 PyObject * obj1 = 0 ;
29668 char *kwnames[] = {
29669 (char *) "self",(char *) "hotkeyId", NULL
29670 };
29671
29672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29674 if (SWIG_arg_fail(1)) SWIG_fail;
29675 {
29676 arg2 = static_cast<int >(SWIG_As_int(obj1));
29677 if (SWIG_arg_fail(2)) SWIG_fail;
29678 }
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29682
29683 wxPyEndAllowThreads(__tstate);
29684 if (PyErr_Occurred()) SWIG_fail;
29685 }
29686 {
29687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29688 }
29689 return resultobj;
29690 fail:
29691 return NULL;
29692 }
29693
29694
29695 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29696 PyObject *resultobj = NULL;
29697 wxWindow *arg1 = (wxWindow *) 0 ;
29698 wxPoint *arg2 = 0 ;
29699 wxPoint result;
29700 wxPoint temp2 ;
29701 PyObject * obj0 = 0 ;
29702 PyObject * obj1 = 0 ;
29703 char *kwnames[] = {
29704 (char *) "self",(char *) "pt", NULL
29705 };
29706
29707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29709 if (SWIG_arg_fail(1)) SWIG_fail;
29710 {
29711 arg2 = &temp2;
29712 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29713 }
29714 {
29715 PyThreadState* __tstate = wxPyBeginAllowThreads();
29716 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29717
29718 wxPyEndAllowThreads(__tstate);
29719 if (PyErr_Occurred()) SWIG_fail;
29720 }
29721 {
29722 wxPoint * resultptr;
29723 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29724 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29725 }
29726 return resultobj;
29727 fail:
29728 return NULL;
29729 }
29730
29731
29732 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29733 PyObject *resultobj = NULL;
29734 wxWindow *arg1 = (wxWindow *) 0 ;
29735 wxSize *arg2 = 0 ;
29736 wxSize result;
29737 wxSize temp2 ;
29738 PyObject * obj0 = 0 ;
29739 PyObject * obj1 = 0 ;
29740 char *kwnames[] = {
29741 (char *) "self",(char *) "sz", NULL
29742 };
29743
29744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29746 if (SWIG_arg_fail(1)) SWIG_fail;
29747 {
29748 arg2 = &temp2;
29749 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29750 }
29751 {
29752 PyThreadState* __tstate = wxPyBeginAllowThreads();
29753 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29754
29755 wxPyEndAllowThreads(__tstate);
29756 if (PyErr_Occurred()) SWIG_fail;
29757 }
29758 {
29759 wxSize * resultptr;
29760 resultptr = new wxSize(static_cast<wxSize & >(result));
29761 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29762 }
29763 return resultobj;
29764 fail:
29765 return NULL;
29766 }
29767
29768
29769 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29770 PyObject *resultobj = NULL;
29771 wxWindow *arg1 = (wxWindow *) 0 ;
29772 wxPoint *arg2 = 0 ;
29773 wxPoint result;
29774 wxPoint temp2 ;
29775 PyObject * obj0 = 0 ;
29776 PyObject * obj1 = 0 ;
29777 char *kwnames[] = {
29778 (char *) "self",(char *) "pt", NULL
29779 };
29780
29781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29783 if (SWIG_arg_fail(1)) SWIG_fail;
29784 {
29785 arg2 = &temp2;
29786 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29787 }
29788 {
29789 PyThreadState* __tstate = wxPyBeginAllowThreads();
29790 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29791
29792 wxPyEndAllowThreads(__tstate);
29793 if (PyErr_Occurred()) SWIG_fail;
29794 }
29795 {
29796 wxPoint * resultptr;
29797 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29798 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29799 }
29800 return resultobj;
29801 fail:
29802 return NULL;
29803 }
29804
29805
29806 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29807 PyObject *resultobj = NULL;
29808 wxWindow *arg1 = (wxWindow *) 0 ;
29809 wxSize *arg2 = 0 ;
29810 wxSize result;
29811 wxSize temp2 ;
29812 PyObject * obj0 = 0 ;
29813 PyObject * obj1 = 0 ;
29814 char *kwnames[] = {
29815 (char *) "self",(char *) "sz", NULL
29816 };
29817
29818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29820 if (SWIG_arg_fail(1)) SWIG_fail;
29821 {
29822 arg2 = &temp2;
29823 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29824 }
29825 {
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29828
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 {
29833 wxSize * resultptr;
29834 resultptr = new wxSize(static_cast<wxSize & >(result));
29835 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29836 }
29837 return resultobj;
29838 fail:
29839 return NULL;
29840 }
29841
29842
29843 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29844 PyObject *resultobj = NULL;
29845 wxWindow *arg1 = (wxWindow *) 0 ;
29846 wxPoint *arg2 = 0 ;
29847 wxPoint result;
29848 wxPoint temp2 ;
29849 PyObject * obj0 = 0 ;
29850 PyObject * obj1 = 0 ;
29851 char *kwnames[] = {
29852 (char *) "self",(char *) "pt", NULL
29853 };
29854
29855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29857 if (SWIG_arg_fail(1)) SWIG_fail;
29858 {
29859 arg2 = &temp2;
29860 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29861 }
29862 {
29863 PyThreadState* __tstate = wxPyBeginAllowThreads();
29864 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29865
29866 wxPyEndAllowThreads(__tstate);
29867 if (PyErr_Occurred()) SWIG_fail;
29868 }
29869 {
29870 wxPoint * resultptr;
29871 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29872 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29873 }
29874 return resultobj;
29875 fail:
29876 return NULL;
29877 }
29878
29879
29880 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29881 PyObject *resultobj = NULL;
29882 wxWindow *arg1 = (wxWindow *) 0 ;
29883 wxSize *arg2 = 0 ;
29884 wxSize result;
29885 wxSize temp2 ;
29886 PyObject * obj0 = 0 ;
29887 PyObject * obj1 = 0 ;
29888 char *kwnames[] = {
29889 (char *) "self",(char *) "sz", NULL
29890 };
29891
29892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29894 if (SWIG_arg_fail(1)) SWIG_fail;
29895 {
29896 arg2 = &temp2;
29897 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29898 }
29899 {
29900 PyThreadState* __tstate = wxPyBeginAllowThreads();
29901 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29902
29903 wxPyEndAllowThreads(__tstate);
29904 if (PyErr_Occurred()) SWIG_fail;
29905 }
29906 {
29907 wxSize * resultptr;
29908 resultptr = new wxSize(static_cast<wxSize & >(result));
29909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29910 }
29911 return resultobj;
29912 fail:
29913 return NULL;
29914 }
29915
29916
29917 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29918 PyObject *resultobj = NULL;
29919 wxWindow *arg1 = (wxWindow *) 0 ;
29920 int arg2 ;
29921 int arg3 ;
29922 PyObject * obj0 = 0 ;
29923 PyObject * obj1 = 0 ;
29924 PyObject * obj2 = 0 ;
29925 char *kwnames[] = {
29926 (char *) "self",(char *) "x",(char *) "y", NULL
29927 };
29928
29929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29931 if (SWIG_arg_fail(1)) SWIG_fail;
29932 {
29933 arg2 = static_cast<int >(SWIG_As_int(obj1));
29934 if (SWIG_arg_fail(2)) SWIG_fail;
29935 }
29936 {
29937 arg3 = static_cast<int >(SWIG_As_int(obj2));
29938 if (SWIG_arg_fail(3)) SWIG_fail;
29939 }
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 (arg1)->WarpPointer(arg2,arg3);
29943
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 Py_INCREF(Py_None); resultobj = Py_None;
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29955 PyObject *resultobj = NULL;
29956 wxWindow *arg1 = (wxWindow *) 0 ;
29957 PyObject * obj0 = 0 ;
29958 char *kwnames[] = {
29959 (char *) "self", NULL
29960 };
29961
29962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29964 if (SWIG_arg_fail(1)) SWIG_fail;
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 (arg1)->CaptureMouse();
29968
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 Py_INCREF(Py_None); resultobj = Py_None;
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29980 PyObject *resultobj = NULL;
29981 wxWindow *arg1 = (wxWindow *) 0 ;
29982 PyObject * obj0 = 0 ;
29983 char *kwnames[] = {
29984 (char *) "self", NULL
29985 };
29986
29987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29989 if (SWIG_arg_fail(1)) SWIG_fail;
29990 {
29991 PyThreadState* __tstate = wxPyBeginAllowThreads();
29992 (arg1)->ReleaseMouse();
29993
29994 wxPyEndAllowThreads(__tstate);
29995 if (PyErr_Occurred()) SWIG_fail;
29996 }
29997 Py_INCREF(Py_None); resultobj = Py_None;
29998 return resultobj;
29999 fail:
30000 return NULL;
30001 }
30002
30003
30004 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
30005 PyObject *resultobj = NULL;
30006 wxWindow *result;
30007 char *kwnames[] = {
30008 NULL
30009 };
30010
30011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
30012 {
30013 if (!wxPyCheckForApp()) SWIG_fail;
30014 PyThreadState* __tstate = wxPyBeginAllowThreads();
30015 result = (wxWindow *)wxWindow::GetCapture();
30016
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 {
30021 resultobj = wxPyMake_wxObject(result, 0);
30022 }
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
30030 PyObject *resultobj = NULL;
30031 wxWindow *arg1 = (wxWindow *) 0 ;
30032 bool result;
30033 PyObject * obj0 = 0 ;
30034 char *kwnames[] = {
30035 (char *) "self", NULL
30036 };
30037
30038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
30039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30040 if (SWIG_arg_fail(1)) SWIG_fail;
30041 {
30042 PyThreadState* __tstate = wxPyBeginAllowThreads();
30043 result = (bool)((wxWindow const *)arg1)->HasCapture();
30044
30045 wxPyEndAllowThreads(__tstate);
30046 if (PyErr_Occurred()) SWIG_fail;
30047 }
30048 {
30049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30050 }
30051 return resultobj;
30052 fail:
30053 return NULL;
30054 }
30055
30056
30057 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30058 PyObject *resultobj = NULL;
30059 wxWindow *arg1 = (wxWindow *) 0 ;
30060 bool arg2 = (bool) true ;
30061 wxRect *arg3 = (wxRect *) NULL ;
30062 PyObject * obj0 = 0 ;
30063 PyObject * obj1 = 0 ;
30064 PyObject * obj2 = 0 ;
30065 char *kwnames[] = {
30066 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30067 };
30068
30069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30071 if (SWIG_arg_fail(1)) SWIG_fail;
30072 if (obj1) {
30073 {
30074 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30075 if (SWIG_arg_fail(2)) SWIG_fail;
30076 }
30077 }
30078 if (obj2) {
30079 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30080 if (SWIG_arg_fail(3)) SWIG_fail;
30081 }
30082 {
30083 PyThreadState* __tstate = wxPyBeginAllowThreads();
30084 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30085
30086 wxPyEndAllowThreads(__tstate);
30087 if (PyErr_Occurred()) SWIG_fail;
30088 }
30089 Py_INCREF(Py_None); resultobj = Py_None;
30090 return resultobj;
30091 fail:
30092 return NULL;
30093 }
30094
30095
30096 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30097 PyObject *resultobj = NULL;
30098 wxWindow *arg1 = (wxWindow *) 0 ;
30099 wxRect *arg2 = 0 ;
30100 bool arg3 = (bool) true ;
30101 wxRect temp2 ;
30102 PyObject * obj0 = 0 ;
30103 PyObject * obj1 = 0 ;
30104 PyObject * obj2 = 0 ;
30105 char *kwnames[] = {
30106 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30107 };
30108
30109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30111 if (SWIG_arg_fail(1)) SWIG_fail;
30112 {
30113 arg2 = &temp2;
30114 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30115 }
30116 if (obj2) {
30117 {
30118 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30119 if (SWIG_arg_fail(3)) SWIG_fail;
30120 }
30121 }
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30125
30126 wxPyEndAllowThreads(__tstate);
30127 if (PyErr_Occurred()) SWIG_fail;
30128 }
30129 Py_INCREF(Py_None); resultobj = Py_None;
30130 return resultobj;
30131 fail:
30132 return NULL;
30133 }
30134
30135
30136 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30137 PyObject *resultobj = NULL;
30138 wxWindow *arg1 = (wxWindow *) 0 ;
30139 PyObject * obj0 = 0 ;
30140 char *kwnames[] = {
30141 (char *) "self", NULL
30142 };
30143
30144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30146 if (SWIG_arg_fail(1)) SWIG_fail;
30147 {
30148 PyThreadState* __tstate = wxPyBeginAllowThreads();
30149 (arg1)->Update();
30150
30151 wxPyEndAllowThreads(__tstate);
30152 if (PyErr_Occurred()) SWIG_fail;
30153 }
30154 Py_INCREF(Py_None); resultobj = Py_None;
30155 return resultobj;
30156 fail:
30157 return NULL;
30158 }
30159
30160
30161 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30162 PyObject *resultobj = NULL;
30163 wxWindow *arg1 = (wxWindow *) 0 ;
30164 PyObject * obj0 = 0 ;
30165 char *kwnames[] = {
30166 (char *) "self", NULL
30167 };
30168
30169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30171 if (SWIG_arg_fail(1)) SWIG_fail;
30172 {
30173 PyThreadState* __tstate = wxPyBeginAllowThreads();
30174 (arg1)->ClearBackground();
30175
30176 wxPyEndAllowThreads(__tstate);
30177 if (PyErr_Occurred()) SWIG_fail;
30178 }
30179 Py_INCREF(Py_None); resultobj = Py_None;
30180 return resultobj;
30181 fail:
30182 return NULL;
30183 }
30184
30185
30186 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30187 PyObject *resultobj = NULL;
30188 wxWindow *arg1 = (wxWindow *) 0 ;
30189 PyObject * obj0 = 0 ;
30190 char *kwnames[] = {
30191 (char *) "self", NULL
30192 };
30193
30194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30196 if (SWIG_arg_fail(1)) SWIG_fail;
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 (arg1)->Freeze();
30200
30201 wxPyEndAllowThreads(__tstate);
30202 if (PyErr_Occurred()) SWIG_fail;
30203 }
30204 Py_INCREF(Py_None); resultobj = Py_None;
30205 return resultobj;
30206 fail:
30207 return NULL;
30208 }
30209
30210
30211 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30212 PyObject *resultobj = NULL;
30213 wxWindow *arg1 = (wxWindow *) 0 ;
30214 PyObject * obj0 = 0 ;
30215 char *kwnames[] = {
30216 (char *) "self", NULL
30217 };
30218
30219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30221 if (SWIG_arg_fail(1)) SWIG_fail;
30222 {
30223 PyThreadState* __tstate = wxPyBeginAllowThreads();
30224 (arg1)->Thaw();
30225
30226 wxPyEndAllowThreads(__tstate);
30227 if (PyErr_Occurred()) SWIG_fail;
30228 }
30229 Py_INCREF(Py_None); resultobj = Py_None;
30230 return resultobj;
30231 fail:
30232 return NULL;
30233 }
30234
30235
30236 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30237 PyObject *resultobj = NULL;
30238 wxWindow *arg1 = (wxWindow *) 0 ;
30239 wxDC *arg2 = 0 ;
30240 PyObject * obj0 = 0 ;
30241 PyObject * obj1 = 0 ;
30242 char *kwnames[] = {
30243 (char *) "self",(char *) "dc", NULL
30244 };
30245
30246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30248 if (SWIG_arg_fail(1)) SWIG_fail;
30249 {
30250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30251 if (SWIG_arg_fail(2)) SWIG_fail;
30252 if (arg2 == NULL) {
30253 SWIG_null_ref("wxDC");
30254 }
30255 if (SWIG_arg_fail(2)) SWIG_fail;
30256 }
30257 {
30258 PyThreadState* __tstate = wxPyBeginAllowThreads();
30259 (arg1)->PrepareDC(*arg2);
30260
30261 wxPyEndAllowThreads(__tstate);
30262 if (PyErr_Occurred()) SWIG_fail;
30263 }
30264 Py_INCREF(Py_None); resultobj = Py_None;
30265 return resultobj;
30266 fail:
30267 return NULL;
30268 }
30269
30270
30271 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30272 PyObject *resultobj = NULL;
30273 wxWindow *arg1 = (wxWindow *) 0 ;
30274 wxRegion *result;
30275 PyObject * obj0 = 0 ;
30276 char *kwnames[] = {
30277 (char *) "self", NULL
30278 };
30279
30280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30282 if (SWIG_arg_fail(1)) SWIG_fail;
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 {
30286 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30287 result = (wxRegion *) &_result_ref;
30288 }
30289
30290 wxPyEndAllowThreads(__tstate);
30291 if (PyErr_Occurred()) SWIG_fail;
30292 }
30293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30294 return resultobj;
30295 fail:
30296 return NULL;
30297 }
30298
30299
30300 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30301 PyObject *resultobj = NULL;
30302 wxWindow *arg1 = (wxWindow *) 0 ;
30303 wxRect result;
30304 PyObject * obj0 = 0 ;
30305 char *kwnames[] = {
30306 (char *) "self", NULL
30307 };
30308
30309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30311 if (SWIG_arg_fail(1)) SWIG_fail;
30312 {
30313 PyThreadState* __tstate = wxPyBeginAllowThreads();
30314 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30315
30316 wxPyEndAllowThreads(__tstate);
30317 if (PyErr_Occurred()) SWIG_fail;
30318 }
30319 {
30320 wxRect * resultptr;
30321 resultptr = new wxRect(static_cast<wxRect & >(result));
30322 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30323 }
30324 return resultobj;
30325 fail:
30326 return NULL;
30327 }
30328
30329
30330 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30331 PyObject *resultobj = NULL;
30332 wxWindow *arg1 = (wxWindow *) 0 ;
30333 int arg2 ;
30334 int arg3 ;
30335 int arg4 = (int) 1 ;
30336 int arg5 = (int) 1 ;
30337 bool result;
30338 PyObject * obj0 = 0 ;
30339 PyObject * obj1 = 0 ;
30340 PyObject * obj2 = 0 ;
30341 PyObject * obj3 = 0 ;
30342 PyObject * obj4 = 0 ;
30343 char *kwnames[] = {
30344 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30345 };
30346
30347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30349 if (SWIG_arg_fail(1)) SWIG_fail;
30350 {
30351 arg2 = static_cast<int >(SWIG_As_int(obj1));
30352 if (SWIG_arg_fail(2)) SWIG_fail;
30353 }
30354 {
30355 arg3 = static_cast<int >(SWIG_As_int(obj2));
30356 if (SWIG_arg_fail(3)) SWIG_fail;
30357 }
30358 if (obj3) {
30359 {
30360 arg4 = static_cast<int >(SWIG_As_int(obj3));
30361 if (SWIG_arg_fail(4)) SWIG_fail;
30362 }
30363 }
30364 if (obj4) {
30365 {
30366 arg5 = static_cast<int >(SWIG_As_int(obj4));
30367 if (SWIG_arg_fail(5)) SWIG_fail;
30368 }
30369 }
30370 {
30371 PyThreadState* __tstate = wxPyBeginAllowThreads();
30372 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30373
30374 wxPyEndAllowThreads(__tstate);
30375 if (PyErr_Occurred()) SWIG_fail;
30376 }
30377 {
30378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30379 }
30380 return resultobj;
30381 fail:
30382 return NULL;
30383 }
30384
30385
30386 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30387 PyObject *resultobj = NULL;
30388 wxWindow *arg1 = (wxWindow *) 0 ;
30389 wxPoint *arg2 = 0 ;
30390 bool result;
30391 wxPoint temp2 ;
30392 PyObject * obj0 = 0 ;
30393 PyObject * obj1 = 0 ;
30394 char *kwnames[] = {
30395 (char *) "self",(char *) "pt", NULL
30396 };
30397
30398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30400 if (SWIG_arg_fail(1)) SWIG_fail;
30401 {
30402 arg2 = &temp2;
30403 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30404 }
30405 {
30406 PyThreadState* __tstate = wxPyBeginAllowThreads();
30407 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30408
30409 wxPyEndAllowThreads(__tstate);
30410 if (PyErr_Occurred()) SWIG_fail;
30411 }
30412 {
30413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30414 }
30415 return resultobj;
30416 fail:
30417 return NULL;
30418 }
30419
30420
30421 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30422 PyObject *resultobj = NULL;
30423 wxWindow *arg1 = (wxWindow *) 0 ;
30424 wxRect *arg2 = 0 ;
30425 bool result;
30426 wxRect temp2 ;
30427 PyObject * obj0 = 0 ;
30428 PyObject * obj1 = 0 ;
30429 char *kwnames[] = {
30430 (char *) "self",(char *) "rect", NULL
30431 };
30432
30433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30435 if (SWIG_arg_fail(1)) SWIG_fail;
30436 {
30437 arg2 = &temp2;
30438 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30439 }
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30443
30444 wxPyEndAllowThreads(__tstate);
30445 if (PyErr_Occurred()) SWIG_fail;
30446 }
30447 {
30448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30449 }
30450 return resultobj;
30451 fail:
30452 return NULL;
30453 }
30454
30455
30456 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30457 PyObject *resultobj = NULL;
30458 wxWindow *arg1 = (wxWindow *) 0 ;
30459 wxVisualAttributes result;
30460 PyObject * obj0 = 0 ;
30461 char *kwnames[] = {
30462 (char *) "self", NULL
30463 };
30464
30465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30467 if (SWIG_arg_fail(1)) SWIG_fail;
30468 {
30469 PyThreadState* __tstate = wxPyBeginAllowThreads();
30470 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30471
30472 wxPyEndAllowThreads(__tstate);
30473 if (PyErr_Occurred()) SWIG_fail;
30474 }
30475 {
30476 wxVisualAttributes * resultptr;
30477 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30478 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30479 }
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj = NULL;
30488 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30489 wxVisualAttributes result;
30490 PyObject * obj0 = 0 ;
30491 char *kwnames[] = {
30492 (char *) "variant", NULL
30493 };
30494
30495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30496 if (obj0) {
30497 {
30498 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 }
30501 }
30502 {
30503 if (!wxPyCheckForApp()) SWIG_fail;
30504 PyThreadState* __tstate = wxPyBeginAllowThreads();
30505 result = wxWindow::GetClassDefaultAttributes(arg1);
30506
30507 wxPyEndAllowThreads(__tstate);
30508 if (PyErr_Occurred()) SWIG_fail;
30509 }
30510 {
30511 wxVisualAttributes * resultptr;
30512 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30514 }
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30522 PyObject *resultobj = NULL;
30523 wxWindow *arg1 = (wxWindow *) 0 ;
30524 wxColour *arg2 = 0 ;
30525 bool result;
30526 wxColour temp2 ;
30527 PyObject * obj0 = 0 ;
30528 PyObject * obj1 = 0 ;
30529 char *kwnames[] = {
30530 (char *) "self",(char *) "colour", NULL
30531 };
30532
30533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30535 if (SWIG_arg_fail(1)) SWIG_fail;
30536 {
30537 arg2 = &temp2;
30538 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30539 }
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30543
30544 wxPyEndAllowThreads(__tstate);
30545 if (PyErr_Occurred()) SWIG_fail;
30546 }
30547 {
30548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30549 }
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30557 PyObject *resultobj = NULL;
30558 wxWindow *arg1 = (wxWindow *) 0 ;
30559 wxColour *arg2 = 0 ;
30560 wxColour temp2 ;
30561 PyObject * obj0 = 0 ;
30562 PyObject * obj1 = 0 ;
30563 char *kwnames[] = {
30564 (char *) "self",(char *) "colour", NULL
30565 };
30566
30567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30569 if (SWIG_arg_fail(1)) SWIG_fail;
30570 {
30571 arg2 = &temp2;
30572 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30573 }
30574 {
30575 PyThreadState* __tstate = wxPyBeginAllowThreads();
30576 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30577
30578 wxPyEndAllowThreads(__tstate);
30579 if (PyErr_Occurred()) SWIG_fail;
30580 }
30581 Py_INCREF(Py_None); resultobj = Py_None;
30582 return resultobj;
30583 fail:
30584 return NULL;
30585 }
30586
30587
30588 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30589 PyObject *resultobj = NULL;
30590 wxWindow *arg1 = (wxWindow *) 0 ;
30591 wxColour *arg2 = 0 ;
30592 bool result;
30593 wxColour temp2 ;
30594 PyObject * obj0 = 0 ;
30595 PyObject * obj1 = 0 ;
30596 char *kwnames[] = {
30597 (char *) "self",(char *) "colour", NULL
30598 };
30599
30600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30602 if (SWIG_arg_fail(1)) SWIG_fail;
30603 {
30604 arg2 = &temp2;
30605 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30606 }
30607 {
30608 PyThreadState* __tstate = wxPyBeginAllowThreads();
30609 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30610
30611 wxPyEndAllowThreads(__tstate);
30612 if (PyErr_Occurred()) SWIG_fail;
30613 }
30614 {
30615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30616 }
30617 return resultobj;
30618 fail:
30619 return NULL;
30620 }
30621
30622
30623 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30624 PyObject *resultobj = NULL;
30625 wxWindow *arg1 = (wxWindow *) 0 ;
30626 wxColour *arg2 = 0 ;
30627 wxColour temp2 ;
30628 PyObject * obj0 = 0 ;
30629 PyObject * obj1 = 0 ;
30630 char *kwnames[] = {
30631 (char *) "self",(char *) "colour", NULL
30632 };
30633
30634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30636 if (SWIG_arg_fail(1)) SWIG_fail;
30637 {
30638 arg2 = &temp2;
30639 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30640 }
30641 {
30642 PyThreadState* __tstate = wxPyBeginAllowThreads();
30643 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30644
30645 wxPyEndAllowThreads(__tstate);
30646 if (PyErr_Occurred()) SWIG_fail;
30647 }
30648 Py_INCREF(Py_None); resultobj = Py_None;
30649 return resultobj;
30650 fail:
30651 return NULL;
30652 }
30653
30654
30655 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30656 PyObject *resultobj = NULL;
30657 wxWindow *arg1 = (wxWindow *) 0 ;
30658 wxColour result;
30659 PyObject * obj0 = 0 ;
30660 char *kwnames[] = {
30661 (char *) "self", NULL
30662 };
30663
30664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30666 if (SWIG_arg_fail(1)) SWIG_fail;
30667 {
30668 PyThreadState* __tstate = wxPyBeginAllowThreads();
30669 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30670
30671 wxPyEndAllowThreads(__tstate);
30672 if (PyErr_Occurred()) SWIG_fail;
30673 }
30674 {
30675 wxColour * resultptr;
30676 resultptr = new wxColour(static_cast<wxColour & >(result));
30677 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30678 }
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30686 PyObject *resultobj = NULL;
30687 wxWindow *arg1 = (wxWindow *) 0 ;
30688 wxColour result;
30689 PyObject * obj0 = 0 ;
30690 char *kwnames[] = {
30691 (char *) "self", NULL
30692 };
30693
30694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30696 if (SWIG_arg_fail(1)) SWIG_fail;
30697 {
30698 PyThreadState* __tstate = wxPyBeginAllowThreads();
30699 result = ((wxWindow const *)arg1)->GetForegroundColour();
30700
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 {
30705 wxColour * resultptr;
30706 resultptr = new wxColour(static_cast<wxColour & >(result));
30707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30708 }
30709 return resultobj;
30710 fail:
30711 return NULL;
30712 }
30713
30714
30715 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30716 PyObject *resultobj = NULL;
30717 wxWindow *arg1 = (wxWindow *) 0 ;
30718 bool result;
30719 PyObject * obj0 = 0 ;
30720 char *kwnames[] = {
30721 (char *) "self", NULL
30722 };
30723
30724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30726 if (SWIG_arg_fail(1)) SWIG_fail;
30727 {
30728 PyThreadState* __tstate = wxPyBeginAllowThreads();
30729 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30730
30731 wxPyEndAllowThreads(__tstate);
30732 if (PyErr_Occurred()) SWIG_fail;
30733 }
30734 {
30735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30736 }
30737 return resultobj;
30738 fail:
30739 return NULL;
30740 }
30741
30742
30743 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30744 PyObject *resultobj = NULL;
30745 wxWindow *arg1 = (wxWindow *) 0 ;
30746 bool result;
30747 PyObject * obj0 = 0 ;
30748 char *kwnames[] = {
30749 (char *) "self", NULL
30750 };
30751
30752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30754 if (SWIG_arg_fail(1)) SWIG_fail;
30755 {
30756 PyThreadState* __tstate = wxPyBeginAllowThreads();
30757 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30758
30759 wxPyEndAllowThreads(__tstate);
30760 if (PyErr_Occurred()) SWIG_fail;
30761 }
30762 {
30763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30764 }
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30772 PyObject *resultobj = NULL;
30773 wxWindow *arg1 = (wxWindow *) 0 ;
30774 wxBackgroundStyle arg2 ;
30775 bool result;
30776 PyObject * obj0 = 0 ;
30777 PyObject * obj1 = 0 ;
30778 char *kwnames[] = {
30779 (char *) "self",(char *) "style", NULL
30780 };
30781
30782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30784 if (SWIG_arg_fail(1)) SWIG_fail;
30785 {
30786 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30787 if (SWIG_arg_fail(2)) SWIG_fail;
30788 }
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30792
30793 wxPyEndAllowThreads(__tstate);
30794 if (PyErr_Occurred()) SWIG_fail;
30795 }
30796 {
30797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30798 }
30799 return resultobj;
30800 fail:
30801 return NULL;
30802 }
30803
30804
30805 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30806 PyObject *resultobj = NULL;
30807 wxWindow *arg1 = (wxWindow *) 0 ;
30808 wxBackgroundStyle result;
30809 PyObject * obj0 = 0 ;
30810 char *kwnames[] = {
30811 (char *) "self", NULL
30812 };
30813
30814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30816 if (SWIG_arg_fail(1)) SWIG_fail;
30817 {
30818 PyThreadState* __tstate = wxPyBeginAllowThreads();
30819 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30820
30821 wxPyEndAllowThreads(__tstate);
30822 if (PyErr_Occurred()) SWIG_fail;
30823 }
30824 resultobj = SWIG_From_int((result));
30825 return resultobj;
30826 fail:
30827 return NULL;
30828 }
30829
30830
30831 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30832 PyObject *resultobj = NULL;
30833 wxWindow *arg1 = (wxWindow *) 0 ;
30834 bool result;
30835 PyObject * obj0 = 0 ;
30836 char *kwnames[] = {
30837 (char *) "self", NULL
30838 };
30839
30840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30842 if (SWIG_arg_fail(1)) SWIG_fail;
30843 {
30844 PyThreadState* __tstate = wxPyBeginAllowThreads();
30845 result = (bool)(arg1)->HasTransparentBackground();
30846
30847 wxPyEndAllowThreads(__tstate);
30848 if (PyErr_Occurred()) SWIG_fail;
30849 }
30850 {
30851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30852 }
30853 return resultobj;
30854 fail:
30855 return NULL;
30856 }
30857
30858
30859 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30860 PyObject *resultobj = NULL;
30861 wxWindow *arg1 = (wxWindow *) 0 ;
30862 wxCursor *arg2 = 0 ;
30863 bool result;
30864 PyObject * obj0 = 0 ;
30865 PyObject * obj1 = 0 ;
30866 char *kwnames[] = {
30867 (char *) "self",(char *) "cursor", NULL
30868 };
30869
30870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30872 if (SWIG_arg_fail(1)) SWIG_fail;
30873 {
30874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30875 if (SWIG_arg_fail(2)) SWIG_fail;
30876 if (arg2 == NULL) {
30877 SWIG_null_ref("wxCursor");
30878 }
30879 if (SWIG_arg_fail(2)) SWIG_fail;
30880 }
30881 {
30882 PyThreadState* __tstate = wxPyBeginAllowThreads();
30883 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30884
30885 wxPyEndAllowThreads(__tstate);
30886 if (PyErr_Occurred()) SWIG_fail;
30887 }
30888 {
30889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30890 }
30891 return resultobj;
30892 fail:
30893 return NULL;
30894 }
30895
30896
30897 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30898 PyObject *resultobj = NULL;
30899 wxWindow *arg1 = (wxWindow *) 0 ;
30900 wxCursor result;
30901 PyObject * obj0 = 0 ;
30902 char *kwnames[] = {
30903 (char *) "self", NULL
30904 };
30905
30906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30908 if (SWIG_arg_fail(1)) SWIG_fail;
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 result = (arg1)->GetCursor();
30912
30913 wxPyEndAllowThreads(__tstate);
30914 if (PyErr_Occurred()) SWIG_fail;
30915 }
30916 {
30917 wxCursor * resultptr;
30918 resultptr = new wxCursor(static_cast<wxCursor & >(result));
30919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30920 }
30921 return resultobj;
30922 fail:
30923 return NULL;
30924 }
30925
30926
30927 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30928 PyObject *resultobj = NULL;
30929 wxWindow *arg1 = (wxWindow *) 0 ;
30930 wxFont *arg2 = 0 ;
30931 bool result;
30932 PyObject * obj0 = 0 ;
30933 PyObject * obj1 = 0 ;
30934 char *kwnames[] = {
30935 (char *) "self",(char *) "font", NULL
30936 };
30937
30938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30940 if (SWIG_arg_fail(1)) SWIG_fail;
30941 {
30942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30943 if (SWIG_arg_fail(2)) SWIG_fail;
30944 if (arg2 == NULL) {
30945 SWIG_null_ref("wxFont");
30946 }
30947 if (SWIG_arg_fail(2)) SWIG_fail;
30948 }
30949 {
30950 PyThreadState* __tstate = wxPyBeginAllowThreads();
30951 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30952
30953 wxPyEndAllowThreads(__tstate);
30954 if (PyErr_Occurred()) SWIG_fail;
30955 }
30956 {
30957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30958 }
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj = NULL;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 wxFont *arg2 = 0 ;
30969 PyObject * obj0 = 0 ;
30970 PyObject * obj1 = 0 ;
30971 char *kwnames[] = {
30972 (char *) "self",(char *) "font", NULL
30973 };
30974
30975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30977 if (SWIG_arg_fail(1)) SWIG_fail;
30978 {
30979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30980 if (SWIG_arg_fail(2)) SWIG_fail;
30981 if (arg2 == NULL) {
30982 SWIG_null_ref("wxFont");
30983 }
30984 if (SWIG_arg_fail(2)) SWIG_fail;
30985 }
30986 {
30987 PyThreadState* __tstate = wxPyBeginAllowThreads();
30988 (arg1)->SetOwnFont((wxFont const &)*arg2);
30989
30990 wxPyEndAllowThreads(__tstate);
30991 if (PyErr_Occurred()) SWIG_fail;
30992 }
30993 Py_INCREF(Py_None); resultobj = Py_None;
30994 return resultobj;
30995 fail:
30996 return NULL;
30997 }
30998
30999
31000 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
31001 PyObject *resultobj = NULL;
31002 wxWindow *arg1 = (wxWindow *) 0 ;
31003 wxFont result;
31004 PyObject * obj0 = 0 ;
31005 char *kwnames[] = {
31006 (char *) "self", NULL
31007 };
31008
31009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
31010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31011 if (SWIG_arg_fail(1)) SWIG_fail;
31012 {
31013 PyThreadState* __tstate = wxPyBeginAllowThreads();
31014 result = (arg1)->GetFont();
31015
31016 wxPyEndAllowThreads(__tstate);
31017 if (PyErr_Occurred()) SWIG_fail;
31018 }
31019 {
31020 wxFont * resultptr;
31021 resultptr = new wxFont(static_cast<wxFont & >(result));
31022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
31023 }
31024 return resultobj;
31025 fail:
31026 return NULL;
31027 }
31028
31029
31030 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31031 PyObject *resultobj = NULL;
31032 wxWindow *arg1 = (wxWindow *) 0 ;
31033 wxCaret *arg2 = (wxCaret *) 0 ;
31034 PyObject * obj0 = 0 ;
31035 PyObject * obj1 = 0 ;
31036 char *kwnames[] = {
31037 (char *) "self",(char *) "caret", NULL
31038 };
31039
31040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
31041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31042 if (SWIG_arg_fail(1)) SWIG_fail;
31043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31044 if (SWIG_arg_fail(2)) SWIG_fail;
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 (arg1)->SetCaret(arg2);
31048
31049 wxPyEndAllowThreads(__tstate);
31050 if (PyErr_Occurred()) SWIG_fail;
31051 }
31052 Py_INCREF(Py_None); resultobj = Py_None;
31053 return resultobj;
31054 fail:
31055 return NULL;
31056 }
31057
31058
31059 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31060 PyObject *resultobj = NULL;
31061 wxWindow *arg1 = (wxWindow *) 0 ;
31062 wxCaret *result;
31063 PyObject * obj0 = 0 ;
31064 char *kwnames[] = {
31065 (char *) "self", NULL
31066 };
31067
31068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
31069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31070 if (SWIG_arg_fail(1)) SWIG_fail;
31071 {
31072 PyThreadState* __tstate = wxPyBeginAllowThreads();
31073 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31074
31075 wxPyEndAllowThreads(__tstate);
31076 if (PyErr_Occurred()) SWIG_fail;
31077 }
31078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31079 return resultobj;
31080 fail:
31081 return NULL;
31082 }
31083
31084
31085 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31086 PyObject *resultobj = NULL;
31087 wxWindow *arg1 = (wxWindow *) 0 ;
31088 int result;
31089 PyObject * obj0 = 0 ;
31090 char *kwnames[] = {
31091 (char *) "self", NULL
31092 };
31093
31094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31096 if (SWIG_arg_fail(1)) SWIG_fail;
31097 {
31098 PyThreadState* __tstate = wxPyBeginAllowThreads();
31099 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31100
31101 wxPyEndAllowThreads(__tstate);
31102 if (PyErr_Occurred()) SWIG_fail;
31103 }
31104 {
31105 resultobj = SWIG_From_int(static_cast<int >(result));
31106 }
31107 return resultobj;
31108 fail:
31109 return NULL;
31110 }
31111
31112
31113 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31114 PyObject *resultobj = NULL;
31115 wxWindow *arg1 = (wxWindow *) 0 ;
31116 int result;
31117 PyObject * obj0 = 0 ;
31118 char *kwnames[] = {
31119 (char *) "self", NULL
31120 };
31121
31122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31124 if (SWIG_arg_fail(1)) SWIG_fail;
31125 {
31126 PyThreadState* __tstate = wxPyBeginAllowThreads();
31127 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31128
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 {
31133 resultobj = SWIG_From_int(static_cast<int >(result));
31134 }
31135 return resultobj;
31136 fail:
31137 return NULL;
31138 }
31139
31140
31141 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31142 PyObject *resultobj = NULL;
31143 wxWindow *arg1 = (wxWindow *) 0 ;
31144 wxString *arg2 = 0 ;
31145 int *arg3 = (int *) 0 ;
31146 int *arg4 = (int *) 0 ;
31147 bool temp2 = false ;
31148 int temp3 ;
31149 int res3 = 0 ;
31150 int temp4 ;
31151 int res4 = 0 ;
31152 PyObject * obj0 = 0 ;
31153 PyObject * obj1 = 0 ;
31154 char *kwnames[] = {
31155 (char *) "self",(char *) "string", NULL
31156 };
31157
31158 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31159 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31162 if (SWIG_arg_fail(1)) SWIG_fail;
31163 {
31164 arg2 = wxString_in_helper(obj1);
31165 if (arg2 == NULL) SWIG_fail;
31166 temp2 = true;
31167 }
31168 {
31169 PyThreadState* __tstate = wxPyBeginAllowThreads();
31170 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
31171
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 Py_INCREF(Py_None); resultobj = Py_None;
31176 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31177 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31178 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31179 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31180 {
31181 if (temp2)
31182 delete arg2;
31183 }
31184 return resultobj;
31185 fail:
31186 {
31187 if (temp2)
31188 delete arg2;
31189 }
31190 return NULL;
31191 }
31192
31193
31194 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31195 PyObject *resultobj = NULL;
31196 wxWindow *arg1 = (wxWindow *) 0 ;
31197 wxString *arg2 = 0 ;
31198 int *arg3 = (int *) 0 ;
31199 int *arg4 = (int *) 0 ;
31200 int *arg5 = (int *) 0 ;
31201 int *arg6 = (int *) 0 ;
31202 wxFont *arg7 = (wxFont *) NULL ;
31203 bool temp2 = false ;
31204 int temp3 ;
31205 int res3 = 0 ;
31206 int temp4 ;
31207 int res4 = 0 ;
31208 int temp5 ;
31209 int res5 = 0 ;
31210 int temp6 ;
31211 int res6 = 0 ;
31212 PyObject * obj0 = 0 ;
31213 PyObject * obj1 = 0 ;
31214 PyObject * obj2 = 0 ;
31215 char *kwnames[] = {
31216 (char *) "self",(char *) "string",(char *) "font", NULL
31217 };
31218
31219 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31220 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31221 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31222 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31225 if (SWIG_arg_fail(1)) SWIG_fail;
31226 {
31227 arg2 = wxString_in_helper(obj1);
31228 if (arg2 == NULL) SWIG_fail;
31229 temp2 = true;
31230 }
31231 if (obj2) {
31232 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31233 if (SWIG_arg_fail(7)) SWIG_fail;
31234 }
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31238
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 Py_INCREF(Py_None); resultobj = Py_None;
31243 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31244 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31245 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31246 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31247 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31248 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31249 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31250 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31251 {
31252 if (temp2)
31253 delete arg2;
31254 }
31255 return resultobj;
31256 fail:
31257 {
31258 if (temp2)
31259 delete arg2;
31260 }
31261 return NULL;
31262 }
31263
31264
31265 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31266 PyObject *resultobj = NULL;
31267 wxWindow *arg1 = (wxWindow *) 0 ;
31268 int *arg2 = (int *) 0 ;
31269 int *arg3 = (int *) 0 ;
31270 int temp2 ;
31271 int res2 = 0 ;
31272 int temp3 ;
31273 int res3 = 0 ;
31274 PyObject * obj0 = 0 ;
31275 PyObject * obj1 = 0 ;
31276 PyObject * obj2 = 0 ;
31277 char *kwnames[] = {
31278 (char *) "self",(char *) "x",(char *) "y", NULL
31279 };
31280
31281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31283 if (SWIG_arg_fail(1)) SWIG_fail;
31284 {
31285 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31286 temp2 = SWIG_As_int(obj1);
31287 if (SWIG_arg_fail(2)) SWIG_fail;
31288 arg2 = &temp2;
31289 res2 = SWIG_NEWOBJ;
31290 }
31291 }
31292 {
31293 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31294 temp3 = SWIG_As_int(obj2);
31295 if (SWIG_arg_fail(3)) SWIG_fail;
31296 arg3 = &temp3;
31297 res3 = SWIG_NEWOBJ;
31298 }
31299 }
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31303
31304 wxPyEndAllowThreads(__tstate);
31305 if (PyErr_Occurred()) SWIG_fail;
31306 }
31307 Py_INCREF(Py_None); resultobj = Py_None;
31308 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31309 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31310 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31311 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31312 return resultobj;
31313 fail:
31314 return NULL;
31315 }
31316
31317
31318 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31319 PyObject *resultobj = NULL;
31320 wxWindow *arg1 = (wxWindow *) 0 ;
31321 int *arg2 = (int *) 0 ;
31322 int *arg3 = (int *) 0 ;
31323 int temp2 ;
31324 int res2 = 0 ;
31325 int temp3 ;
31326 int res3 = 0 ;
31327 PyObject * obj0 = 0 ;
31328 PyObject * obj1 = 0 ;
31329 PyObject * obj2 = 0 ;
31330 char *kwnames[] = {
31331 (char *) "self",(char *) "x",(char *) "y", NULL
31332 };
31333
31334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31336 if (SWIG_arg_fail(1)) SWIG_fail;
31337 {
31338 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31339 temp2 = SWIG_As_int(obj1);
31340 if (SWIG_arg_fail(2)) SWIG_fail;
31341 arg2 = &temp2;
31342 res2 = SWIG_NEWOBJ;
31343 }
31344 }
31345 {
31346 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31347 temp3 = SWIG_As_int(obj2);
31348 if (SWIG_arg_fail(3)) SWIG_fail;
31349 arg3 = &temp3;
31350 res3 = SWIG_NEWOBJ;
31351 }
31352 }
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31356
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 Py_INCREF(Py_None); resultobj = Py_None;
31361 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31362 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31363 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31364 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31365 return resultobj;
31366 fail:
31367 return NULL;
31368 }
31369
31370
31371 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31372 PyObject *resultobj = NULL;
31373 wxWindow *arg1 = (wxWindow *) 0 ;
31374 wxPoint *arg2 = 0 ;
31375 wxPoint result;
31376 wxPoint temp2 ;
31377 PyObject * obj0 = 0 ;
31378 PyObject * obj1 = 0 ;
31379 char *kwnames[] = {
31380 (char *) "self",(char *) "pt", NULL
31381 };
31382
31383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31385 if (SWIG_arg_fail(1)) SWIG_fail;
31386 {
31387 arg2 = &temp2;
31388 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31389 }
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31393
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 {
31398 wxPoint * resultptr;
31399 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31400 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31401 }
31402 return resultobj;
31403 fail:
31404 return NULL;
31405 }
31406
31407
31408 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31409 PyObject *resultobj = NULL;
31410 wxWindow *arg1 = (wxWindow *) 0 ;
31411 wxPoint *arg2 = 0 ;
31412 wxPoint result;
31413 wxPoint temp2 ;
31414 PyObject * obj0 = 0 ;
31415 PyObject * obj1 = 0 ;
31416 char *kwnames[] = {
31417 (char *) "self",(char *) "pt", NULL
31418 };
31419
31420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31422 if (SWIG_arg_fail(1)) SWIG_fail;
31423 {
31424 arg2 = &temp2;
31425 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31426 }
31427 {
31428 PyThreadState* __tstate = wxPyBeginAllowThreads();
31429 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31430
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 {
31435 wxPoint * resultptr;
31436 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31437 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31438 }
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31446 PyObject *resultobj = NULL;
31447 wxWindow *arg1 = (wxWindow *) 0 ;
31448 int arg2 ;
31449 int arg3 ;
31450 wxHitTest result;
31451 PyObject * obj0 = 0 ;
31452 PyObject * obj1 = 0 ;
31453 PyObject * obj2 = 0 ;
31454 char *kwnames[] = {
31455 (char *) "self",(char *) "x",(char *) "y", NULL
31456 };
31457
31458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31460 if (SWIG_arg_fail(1)) SWIG_fail;
31461 {
31462 arg2 = static_cast<int >(SWIG_As_int(obj1));
31463 if (SWIG_arg_fail(2)) SWIG_fail;
31464 }
31465 {
31466 arg3 = static_cast<int >(SWIG_As_int(obj2));
31467 if (SWIG_arg_fail(3)) SWIG_fail;
31468 }
31469 {
31470 PyThreadState* __tstate = wxPyBeginAllowThreads();
31471 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31472
31473 wxPyEndAllowThreads(__tstate);
31474 if (PyErr_Occurred()) SWIG_fail;
31475 }
31476 resultobj = SWIG_From_int((result));
31477 return resultobj;
31478 fail:
31479 return NULL;
31480 }
31481
31482
31483 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31484 PyObject *resultobj = NULL;
31485 wxWindow *arg1 = (wxWindow *) 0 ;
31486 wxPoint *arg2 = 0 ;
31487 wxHitTest result;
31488 wxPoint temp2 ;
31489 PyObject * obj0 = 0 ;
31490 PyObject * obj1 = 0 ;
31491 char *kwnames[] = {
31492 (char *) "self",(char *) "pt", NULL
31493 };
31494
31495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31497 if (SWIG_arg_fail(1)) SWIG_fail;
31498 {
31499 arg2 = &temp2;
31500 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31501 }
31502 {
31503 PyThreadState* __tstate = wxPyBeginAllowThreads();
31504 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31505
31506 wxPyEndAllowThreads(__tstate);
31507 if (PyErr_Occurred()) SWIG_fail;
31508 }
31509 resultobj = SWIG_From_int((result));
31510 return resultobj;
31511 fail:
31512 return NULL;
31513 }
31514
31515
31516 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31517 PyObject *resultobj = NULL;
31518 wxWindow *arg1 = (wxWindow *) 0 ;
31519 long arg2 ;
31520 wxBorder result;
31521 PyObject * obj0 = 0 ;
31522 PyObject * obj1 = 0 ;
31523
31524 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31526 if (SWIG_arg_fail(1)) SWIG_fail;
31527 {
31528 arg2 = static_cast<long >(SWIG_As_long(obj1));
31529 if (SWIG_arg_fail(2)) SWIG_fail;
31530 }
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31534
31535 wxPyEndAllowThreads(__tstate);
31536 if (PyErr_Occurred()) SWIG_fail;
31537 }
31538 resultobj = SWIG_From_int((result));
31539 return resultobj;
31540 fail:
31541 return NULL;
31542 }
31543
31544
31545 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31546 PyObject *resultobj = NULL;
31547 wxWindow *arg1 = (wxWindow *) 0 ;
31548 wxBorder result;
31549 PyObject * obj0 = 0 ;
31550
31551 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31553 if (SWIG_arg_fail(1)) SWIG_fail;
31554 {
31555 PyThreadState* __tstate = wxPyBeginAllowThreads();
31556 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31557
31558 wxPyEndAllowThreads(__tstate);
31559 if (PyErr_Occurred()) SWIG_fail;
31560 }
31561 resultobj = SWIG_From_int((result));
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31569 int argc;
31570 PyObject *argv[3];
31571 int ii;
31572
31573 argc = PyObject_Length(args);
31574 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31575 argv[ii] = PyTuple_GetItem(args,ii);
31576 }
31577 if (argc == 1) {
31578 int _v;
31579 {
31580 void *ptr;
31581 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31582 _v = 0;
31583 PyErr_Clear();
31584 } else {
31585 _v = 1;
31586 }
31587 }
31588 if (_v) {
31589 return _wrap_Window_GetBorder__SWIG_1(self,args);
31590 }
31591 }
31592 if (argc == 2) {
31593 int _v;
31594 {
31595 void *ptr;
31596 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31597 _v = 0;
31598 PyErr_Clear();
31599 } else {
31600 _v = 1;
31601 }
31602 }
31603 if (_v) {
31604 _v = SWIG_Check_long(argv[1]);
31605 if (_v) {
31606 return _wrap_Window_GetBorder__SWIG_0(self,args);
31607 }
31608 }
31609 }
31610
31611 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31612 return NULL;
31613 }
31614
31615
31616 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31617 PyObject *resultobj = NULL;
31618 wxWindow *arg1 = (wxWindow *) 0 ;
31619 long arg2 = (long) wxUPDATE_UI_NONE ;
31620 PyObject * obj0 = 0 ;
31621 PyObject * obj1 = 0 ;
31622 char *kwnames[] = {
31623 (char *) "self",(char *) "flags", NULL
31624 };
31625
31626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31628 if (SWIG_arg_fail(1)) SWIG_fail;
31629 if (obj1) {
31630 {
31631 arg2 = static_cast<long >(SWIG_As_long(obj1));
31632 if (SWIG_arg_fail(2)) SWIG_fail;
31633 }
31634 }
31635 {
31636 PyThreadState* __tstate = wxPyBeginAllowThreads();
31637 (arg1)->UpdateWindowUI(arg2);
31638
31639 wxPyEndAllowThreads(__tstate);
31640 if (PyErr_Occurred()) SWIG_fail;
31641 }
31642 Py_INCREF(Py_None); resultobj = Py_None;
31643 return resultobj;
31644 fail:
31645 return NULL;
31646 }
31647
31648
31649 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31650 PyObject *resultobj = NULL;
31651 wxWindow *arg1 = (wxWindow *) 0 ;
31652 wxMenu *arg2 = (wxMenu *) 0 ;
31653 int arg3 = (int) -1 ;
31654 int arg4 = (int) -1 ;
31655 bool result;
31656 PyObject * obj0 = 0 ;
31657 PyObject * obj1 = 0 ;
31658 PyObject * obj2 = 0 ;
31659 PyObject * obj3 = 0 ;
31660 char *kwnames[] = {
31661 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31662 };
31663
31664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31666 if (SWIG_arg_fail(1)) SWIG_fail;
31667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31668 if (SWIG_arg_fail(2)) SWIG_fail;
31669 if (obj2) {
31670 {
31671 arg3 = static_cast<int >(SWIG_As_int(obj2));
31672 if (SWIG_arg_fail(3)) SWIG_fail;
31673 }
31674 }
31675 if (obj3) {
31676 {
31677 arg4 = static_cast<int >(SWIG_As_int(obj3));
31678 if (SWIG_arg_fail(4)) SWIG_fail;
31679 }
31680 }
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31684
31685 wxPyEndAllowThreads(__tstate);
31686 if (PyErr_Occurred()) SWIG_fail;
31687 }
31688 {
31689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31690 }
31691 return resultobj;
31692 fail:
31693 return NULL;
31694 }
31695
31696
31697 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31698 PyObject *resultobj = NULL;
31699 wxWindow *arg1 = (wxWindow *) 0 ;
31700 wxMenu *arg2 = (wxMenu *) 0 ;
31701 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31702 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31703 bool result;
31704 wxPoint temp3 ;
31705 PyObject * obj0 = 0 ;
31706 PyObject * obj1 = 0 ;
31707 PyObject * obj2 = 0 ;
31708 char *kwnames[] = {
31709 (char *) "self",(char *) "menu",(char *) "pos", NULL
31710 };
31711
31712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31714 if (SWIG_arg_fail(1)) SWIG_fail;
31715 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31716 if (SWIG_arg_fail(2)) SWIG_fail;
31717 if (obj2) {
31718 {
31719 arg3 = &temp3;
31720 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31721 }
31722 }
31723 {
31724 PyThreadState* __tstate = wxPyBeginAllowThreads();
31725 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31726
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 {
31731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31732 }
31733 return resultobj;
31734 fail:
31735 return NULL;
31736 }
31737
31738
31739 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31740 PyObject *resultobj = NULL;
31741 wxWindow *arg1 = (wxWindow *) 0 ;
31742 long result;
31743 PyObject * obj0 = 0 ;
31744 char *kwnames[] = {
31745 (char *) "self", NULL
31746 };
31747
31748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31750 if (SWIG_arg_fail(1)) SWIG_fail;
31751 {
31752 PyThreadState* __tstate = wxPyBeginAllowThreads();
31753 result = (long)wxWindow_GetHandle(arg1);
31754
31755 wxPyEndAllowThreads(__tstate);
31756 if (PyErr_Occurred()) SWIG_fail;
31757 }
31758 {
31759 resultobj = SWIG_From_long(static_cast<long >(result));
31760 }
31761 return resultobj;
31762 fail:
31763 return NULL;
31764 }
31765
31766
31767 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31768 PyObject *resultobj = NULL;
31769 wxWindow *arg1 = (wxWindow *) 0 ;
31770 long arg2 ;
31771 PyObject * obj0 = 0 ;
31772 PyObject * obj1 = 0 ;
31773 char *kwnames[] = {
31774 (char *) "self",(char *) "handle", NULL
31775 };
31776
31777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31779 if (SWIG_arg_fail(1)) SWIG_fail;
31780 {
31781 arg2 = static_cast<long >(SWIG_As_long(obj1));
31782 if (SWIG_arg_fail(2)) SWIG_fail;
31783 }
31784 {
31785 PyThreadState* __tstate = wxPyBeginAllowThreads();
31786 wxWindow_AssociateHandle(arg1,arg2);
31787
31788 wxPyEndAllowThreads(__tstate);
31789 if (PyErr_Occurred()) SWIG_fail;
31790 }
31791 Py_INCREF(Py_None); resultobj = Py_None;
31792 return resultobj;
31793 fail:
31794 return NULL;
31795 }
31796
31797
31798 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31799 PyObject *resultobj = NULL;
31800 wxWindow *arg1 = (wxWindow *) 0 ;
31801 PyObject * obj0 = 0 ;
31802 char *kwnames[] = {
31803 (char *) "self", NULL
31804 };
31805
31806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31808 if (SWIG_arg_fail(1)) SWIG_fail;
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 (arg1)->DissociateHandle();
31812
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 Py_INCREF(Py_None); resultobj = Py_None;
31817 return resultobj;
31818 fail:
31819 return NULL;
31820 }
31821
31822
31823 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
31824 PyObject *resultobj = NULL;
31825 wxWindow *arg1 = (wxWindow *) 0 ;
31826 wxPaintEvent *arg2 = 0 ;
31827 PyObject * obj0 = 0 ;
31828 PyObject * obj1 = 0 ;
31829 char *kwnames[] = {
31830 (char *) "self",(char *) "event", NULL
31831 };
31832
31833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
31834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31835 if (SWIG_arg_fail(1)) SWIG_fail;
31836 {
31837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
31838 if (SWIG_arg_fail(2)) SWIG_fail;
31839 if (arg2 == NULL) {
31840 SWIG_null_ref("wxPaintEvent");
31841 }
31842 if (SWIG_arg_fail(2)) SWIG_fail;
31843 }
31844 {
31845 PyThreadState* __tstate = wxPyBeginAllowThreads();
31846 (arg1)->OnPaint(*arg2);
31847
31848 wxPyEndAllowThreads(__tstate);
31849 if (PyErr_Occurred()) SWIG_fail;
31850 }
31851 Py_INCREF(Py_None); resultobj = Py_None;
31852 return resultobj;
31853 fail:
31854 return NULL;
31855 }
31856
31857
31858 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31859 PyObject *resultobj = NULL;
31860 wxWindow *arg1 = (wxWindow *) 0 ;
31861 int arg2 ;
31862 bool result;
31863 PyObject * obj0 = 0 ;
31864 PyObject * obj1 = 0 ;
31865 char *kwnames[] = {
31866 (char *) "self",(char *) "orient", NULL
31867 };
31868
31869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31871 if (SWIG_arg_fail(1)) SWIG_fail;
31872 {
31873 arg2 = static_cast<int >(SWIG_As_int(obj1));
31874 if (SWIG_arg_fail(2)) SWIG_fail;
31875 }
31876 {
31877 PyThreadState* __tstate = wxPyBeginAllowThreads();
31878 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31879
31880 wxPyEndAllowThreads(__tstate);
31881 if (PyErr_Occurred()) SWIG_fail;
31882 }
31883 {
31884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31885 }
31886 return resultobj;
31887 fail:
31888 return NULL;
31889 }
31890
31891
31892 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31893 PyObject *resultobj = NULL;
31894 wxWindow *arg1 = (wxWindow *) 0 ;
31895 int arg2 ;
31896 int arg3 ;
31897 int arg4 ;
31898 int arg5 ;
31899 bool arg6 = (bool) true ;
31900 PyObject * obj0 = 0 ;
31901 PyObject * obj1 = 0 ;
31902 PyObject * obj2 = 0 ;
31903 PyObject * obj3 = 0 ;
31904 PyObject * obj4 = 0 ;
31905 PyObject * obj5 = 0 ;
31906 char *kwnames[] = {
31907 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31908 };
31909
31910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31912 if (SWIG_arg_fail(1)) SWIG_fail;
31913 {
31914 arg2 = static_cast<int >(SWIG_As_int(obj1));
31915 if (SWIG_arg_fail(2)) SWIG_fail;
31916 }
31917 {
31918 arg3 = static_cast<int >(SWIG_As_int(obj2));
31919 if (SWIG_arg_fail(3)) SWIG_fail;
31920 }
31921 {
31922 arg4 = static_cast<int >(SWIG_As_int(obj3));
31923 if (SWIG_arg_fail(4)) SWIG_fail;
31924 }
31925 {
31926 arg5 = static_cast<int >(SWIG_As_int(obj4));
31927 if (SWIG_arg_fail(5)) SWIG_fail;
31928 }
31929 if (obj5) {
31930 {
31931 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31932 if (SWIG_arg_fail(6)) SWIG_fail;
31933 }
31934 }
31935 {
31936 PyThreadState* __tstate = wxPyBeginAllowThreads();
31937 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31938
31939 wxPyEndAllowThreads(__tstate);
31940 if (PyErr_Occurred()) SWIG_fail;
31941 }
31942 Py_INCREF(Py_None); resultobj = Py_None;
31943 return resultobj;
31944 fail:
31945 return NULL;
31946 }
31947
31948
31949 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31950 PyObject *resultobj = NULL;
31951 wxWindow *arg1 = (wxWindow *) 0 ;
31952 int arg2 ;
31953 int arg3 ;
31954 bool arg4 = (bool) true ;
31955 PyObject * obj0 = 0 ;
31956 PyObject * obj1 = 0 ;
31957 PyObject * obj2 = 0 ;
31958 PyObject * obj3 = 0 ;
31959 char *kwnames[] = {
31960 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31961 };
31962
31963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31965 if (SWIG_arg_fail(1)) SWIG_fail;
31966 {
31967 arg2 = static_cast<int >(SWIG_As_int(obj1));
31968 if (SWIG_arg_fail(2)) SWIG_fail;
31969 }
31970 {
31971 arg3 = static_cast<int >(SWIG_As_int(obj2));
31972 if (SWIG_arg_fail(3)) SWIG_fail;
31973 }
31974 if (obj3) {
31975 {
31976 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
31977 if (SWIG_arg_fail(4)) SWIG_fail;
31978 }
31979 }
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 (arg1)->SetScrollPos(arg2,arg3,arg4);
31983
31984 wxPyEndAllowThreads(__tstate);
31985 if (PyErr_Occurred()) SWIG_fail;
31986 }
31987 Py_INCREF(Py_None); resultobj = Py_None;
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31995 PyObject *resultobj = NULL;
31996 wxWindow *arg1 = (wxWindow *) 0 ;
31997 int arg2 ;
31998 int result;
31999 PyObject * obj0 = 0 ;
32000 PyObject * obj1 = 0 ;
32001 char *kwnames[] = {
32002 (char *) "self",(char *) "orientation", NULL
32003 };
32004
32005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
32006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32007 if (SWIG_arg_fail(1)) SWIG_fail;
32008 {
32009 arg2 = static_cast<int >(SWIG_As_int(obj1));
32010 if (SWIG_arg_fail(2)) SWIG_fail;
32011 }
32012 {
32013 PyThreadState* __tstate = wxPyBeginAllowThreads();
32014 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
32015
32016 wxPyEndAllowThreads(__tstate);
32017 if (PyErr_Occurred()) SWIG_fail;
32018 }
32019 {
32020 resultobj = SWIG_From_int(static_cast<int >(result));
32021 }
32022 return resultobj;
32023 fail:
32024 return NULL;
32025 }
32026
32027
32028 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
32029 PyObject *resultobj = NULL;
32030 wxWindow *arg1 = (wxWindow *) 0 ;
32031 int arg2 ;
32032 int result;
32033 PyObject * obj0 = 0 ;
32034 PyObject * obj1 = 0 ;
32035 char *kwnames[] = {
32036 (char *) "self",(char *) "orientation", NULL
32037 };
32038
32039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
32040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32041 if (SWIG_arg_fail(1)) SWIG_fail;
32042 {
32043 arg2 = static_cast<int >(SWIG_As_int(obj1));
32044 if (SWIG_arg_fail(2)) SWIG_fail;
32045 }
32046 {
32047 PyThreadState* __tstate = wxPyBeginAllowThreads();
32048 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
32049
32050 wxPyEndAllowThreads(__tstate);
32051 if (PyErr_Occurred()) SWIG_fail;
32052 }
32053 {
32054 resultobj = SWIG_From_int(static_cast<int >(result));
32055 }
32056 return resultobj;
32057 fail:
32058 return NULL;
32059 }
32060
32061
32062 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
32063 PyObject *resultobj = NULL;
32064 wxWindow *arg1 = (wxWindow *) 0 ;
32065 int arg2 ;
32066 int result;
32067 PyObject * obj0 = 0 ;
32068 PyObject * obj1 = 0 ;
32069 char *kwnames[] = {
32070 (char *) "self",(char *) "orientation", NULL
32071 };
32072
32073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32075 if (SWIG_arg_fail(1)) SWIG_fail;
32076 {
32077 arg2 = static_cast<int >(SWIG_As_int(obj1));
32078 if (SWIG_arg_fail(2)) SWIG_fail;
32079 }
32080 {
32081 PyThreadState* __tstate = wxPyBeginAllowThreads();
32082 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32083
32084 wxPyEndAllowThreads(__tstate);
32085 if (PyErr_Occurred()) SWIG_fail;
32086 }
32087 {
32088 resultobj = SWIG_From_int(static_cast<int >(result));
32089 }
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32097 PyObject *resultobj = NULL;
32098 wxWindow *arg1 = (wxWindow *) 0 ;
32099 int arg2 ;
32100 int arg3 ;
32101 wxRect *arg4 = (wxRect *) NULL ;
32102 PyObject * obj0 = 0 ;
32103 PyObject * obj1 = 0 ;
32104 PyObject * obj2 = 0 ;
32105 PyObject * obj3 = 0 ;
32106 char *kwnames[] = {
32107 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32108 };
32109
32110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32112 if (SWIG_arg_fail(1)) SWIG_fail;
32113 {
32114 arg2 = static_cast<int >(SWIG_As_int(obj1));
32115 if (SWIG_arg_fail(2)) SWIG_fail;
32116 }
32117 {
32118 arg3 = static_cast<int >(SWIG_As_int(obj2));
32119 if (SWIG_arg_fail(3)) SWIG_fail;
32120 }
32121 if (obj3) {
32122 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32123 if (SWIG_arg_fail(4)) SWIG_fail;
32124 }
32125 {
32126 PyThreadState* __tstate = wxPyBeginAllowThreads();
32127 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32128
32129 wxPyEndAllowThreads(__tstate);
32130 if (PyErr_Occurred()) SWIG_fail;
32131 }
32132 Py_INCREF(Py_None); resultobj = Py_None;
32133 return resultobj;
32134 fail:
32135 return NULL;
32136 }
32137
32138
32139 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32140 PyObject *resultobj = NULL;
32141 wxWindow *arg1 = (wxWindow *) 0 ;
32142 int arg2 ;
32143 bool result;
32144 PyObject * obj0 = 0 ;
32145 PyObject * obj1 = 0 ;
32146 char *kwnames[] = {
32147 (char *) "self",(char *) "lines", NULL
32148 };
32149
32150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32152 if (SWIG_arg_fail(1)) SWIG_fail;
32153 {
32154 arg2 = static_cast<int >(SWIG_As_int(obj1));
32155 if (SWIG_arg_fail(2)) SWIG_fail;
32156 }
32157 {
32158 PyThreadState* __tstate = wxPyBeginAllowThreads();
32159 result = (bool)(arg1)->ScrollLines(arg2);
32160
32161 wxPyEndAllowThreads(__tstate);
32162 if (PyErr_Occurred()) SWIG_fail;
32163 }
32164 {
32165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32166 }
32167 return resultobj;
32168 fail:
32169 return NULL;
32170 }
32171
32172
32173 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32174 PyObject *resultobj = NULL;
32175 wxWindow *arg1 = (wxWindow *) 0 ;
32176 int arg2 ;
32177 bool result;
32178 PyObject * obj0 = 0 ;
32179 PyObject * obj1 = 0 ;
32180 char *kwnames[] = {
32181 (char *) "self",(char *) "pages", NULL
32182 };
32183
32184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32186 if (SWIG_arg_fail(1)) SWIG_fail;
32187 {
32188 arg2 = static_cast<int >(SWIG_As_int(obj1));
32189 if (SWIG_arg_fail(2)) SWIG_fail;
32190 }
32191 {
32192 PyThreadState* __tstate = wxPyBeginAllowThreads();
32193 result = (bool)(arg1)->ScrollPages(arg2);
32194
32195 wxPyEndAllowThreads(__tstate);
32196 if (PyErr_Occurred()) SWIG_fail;
32197 }
32198 {
32199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32200 }
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32208 PyObject *resultobj = NULL;
32209 wxWindow *arg1 = (wxWindow *) 0 ;
32210 bool result;
32211 PyObject * obj0 = 0 ;
32212 char *kwnames[] = {
32213 (char *) "self", NULL
32214 };
32215
32216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32218 if (SWIG_arg_fail(1)) SWIG_fail;
32219 {
32220 PyThreadState* __tstate = wxPyBeginAllowThreads();
32221 result = (bool)(arg1)->LineUp();
32222
32223 wxPyEndAllowThreads(__tstate);
32224 if (PyErr_Occurred()) SWIG_fail;
32225 }
32226 {
32227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32228 }
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32236 PyObject *resultobj = NULL;
32237 wxWindow *arg1 = (wxWindow *) 0 ;
32238 bool result;
32239 PyObject * obj0 = 0 ;
32240 char *kwnames[] = {
32241 (char *) "self", NULL
32242 };
32243
32244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32246 if (SWIG_arg_fail(1)) SWIG_fail;
32247 {
32248 PyThreadState* __tstate = wxPyBeginAllowThreads();
32249 result = (bool)(arg1)->LineDown();
32250
32251 wxPyEndAllowThreads(__tstate);
32252 if (PyErr_Occurred()) SWIG_fail;
32253 }
32254 {
32255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32256 }
32257 return resultobj;
32258 fail:
32259 return NULL;
32260 }
32261
32262
32263 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32264 PyObject *resultobj = NULL;
32265 wxWindow *arg1 = (wxWindow *) 0 ;
32266 bool result;
32267 PyObject * obj0 = 0 ;
32268 char *kwnames[] = {
32269 (char *) "self", NULL
32270 };
32271
32272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32274 if (SWIG_arg_fail(1)) SWIG_fail;
32275 {
32276 PyThreadState* __tstate = wxPyBeginAllowThreads();
32277 result = (bool)(arg1)->PageUp();
32278
32279 wxPyEndAllowThreads(__tstate);
32280 if (PyErr_Occurred()) SWIG_fail;
32281 }
32282 {
32283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32284 }
32285 return resultobj;
32286 fail:
32287 return NULL;
32288 }
32289
32290
32291 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32292 PyObject *resultobj = NULL;
32293 wxWindow *arg1 = (wxWindow *) 0 ;
32294 bool result;
32295 PyObject * obj0 = 0 ;
32296 char *kwnames[] = {
32297 (char *) "self", NULL
32298 };
32299
32300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32302 if (SWIG_arg_fail(1)) SWIG_fail;
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 result = (bool)(arg1)->PageDown();
32306
32307 wxPyEndAllowThreads(__tstate);
32308 if (PyErr_Occurred()) SWIG_fail;
32309 }
32310 {
32311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32312 }
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32320 PyObject *resultobj = NULL;
32321 wxWindow *arg1 = (wxWindow *) 0 ;
32322 wxString *arg2 = 0 ;
32323 bool temp2 = false ;
32324 PyObject * obj0 = 0 ;
32325 PyObject * obj1 = 0 ;
32326 char *kwnames[] = {
32327 (char *) "self",(char *) "text", NULL
32328 };
32329
32330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32332 if (SWIG_arg_fail(1)) SWIG_fail;
32333 {
32334 arg2 = wxString_in_helper(obj1);
32335 if (arg2 == NULL) SWIG_fail;
32336 temp2 = true;
32337 }
32338 {
32339 PyThreadState* __tstate = wxPyBeginAllowThreads();
32340 (arg1)->SetHelpText((wxString const &)*arg2);
32341
32342 wxPyEndAllowThreads(__tstate);
32343 if (PyErr_Occurred()) SWIG_fail;
32344 }
32345 Py_INCREF(Py_None); resultobj = Py_None;
32346 {
32347 if (temp2)
32348 delete arg2;
32349 }
32350 return resultobj;
32351 fail:
32352 {
32353 if (temp2)
32354 delete arg2;
32355 }
32356 return NULL;
32357 }
32358
32359
32360 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32361 PyObject *resultobj = NULL;
32362 wxWindow *arg1 = (wxWindow *) 0 ;
32363 wxString *arg2 = 0 ;
32364 bool temp2 = false ;
32365 PyObject * obj0 = 0 ;
32366 PyObject * obj1 = 0 ;
32367 char *kwnames[] = {
32368 (char *) "self",(char *) "text", NULL
32369 };
32370
32371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32373 if (SWIG_arg_fail(1)) SWIG_fail;
32374 {
32375 arg2 = wxString_in_helper(obj1);
32376 if (arg2 == NULL) SWIG_fail;
32377 temp2 = true;
32378 }
32379 {
32380 PyThreadState* __tstate = wxPyBeginAllowThreads();
32381 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32382
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 Py_INCREF(Py_None); resultobj = Py_None;
32387 {
32388 if (temp2)
32389 delete arg2;
32390 }
32391 return resultobj;
32392 fail:
32393 {
32394 if (temp2)
32395 delete arg2;
32396 }
32397 return NULL;
32398 }
32399
32400
32401 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32402 PyObject *resultobj = NULL;
32403 wxWindow *arg1 = (wxWindow *) 0 ;
32404 wxString result;
32405 PyObject * obj0 = 0 ;
32406 char *kwnames[] = {
32407 (char *) "self", NULL
32408 };
32409
32410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32412 if (SWIG_arg_fail(1)) SWIG_fail;
32413 {
32414 PyThreadState* __tstate = wxPyBeginAllowThreads();
32415 result = ((wxWindow const *)arg1)->GetHelpText();
32416
32417 wxPyEndAllowThreads(__tstate);
32418 if (PyErr_Occurred()) SWIG_fail;
32419 }
32420 {
32421 #if wxUSE_UNICODE
32422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32423 #else
32424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32425 #endif
32426 }
32427 return resultobj;
32428 fail:
32429 return NULL;
32430 }
32431
32432
32433 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32434 PyObject *resultobj = NULL;
32435 wxWindow *arg1 = (wxWindow *) 0 ;
32436 wxString *arg2 = 0 ;
32437 bool temp2 = false ;
32438 PyObject * obj0 = 0 ;
32439 PyObject * obj1 = 0 ;
32440 char *kwnames[] = {
32441 (char *) "self",(char *) "tip", NULL
32442 };
32443
32444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32446 if (SWIG_arg_fail(1)) SWIG_fail;
32447 {
32448 arg2 = wxString_in_helper(obj1);
32449 if (arg2 == NULL) SWIG_fail;
32450 temp2 = true;
32451 }
32452 {
32453 PyThreadState* __tstate = wxPyBeginAllowThreads();
32454 (arg1)->SetToolTip((wxString const &)*arg2);
32455
32456 wxPyEndAllowThreads(__tstate);
32457 if (PyErr_Occurred()) SWIG_fail;
32458 }
32459 Py_INCREF(Py_None); resultobj = Py_None;
32460 {
32461 if (temp2)
32462 delete arg2;
32463 }
32464 return resultobj;
32465 fail:
32466 {
32467 if (temp2)
32468 delete arg2;
32469 }
32470 return NULL;
32471 }
32472
32473
32474 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32475 PyObject *resultobj = NULL;
32476 wxWindow *arg1 = (wxWindow *) 0 ;
32477 wxToolTip *arg2 = (wxToolTip *) 0 ;
32478 PyObject * obj0 = 0 ;
32479 PyObject * obj1 = 0 ;
32480 char *kwnames[] = {
32481 (char *) "self",(char *) "tip", NULL
32482 };
32483
32484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32486 if (SWIG_arg_fail(1)) SWIG_fail;
32487 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32488 if (SWIG_arg_fail(2)) SWIG_fail;
32489 {
32490 PyThreadState* __tstate = wxPyBeginAllowThreads();
32491 (arg1)->SetToolTip(arg2);
32492
32493 wxPyEndAllowThreads(__tstate);
32494 if (PyErr_Occurred()) SWIG_fail;
32495 }
32496 Py_INCREF(Py_None); resultobj = Py_None;
32497 return resultobj;
32498 fail:
32499 return NULL;
32500 }
32501
32502
32503 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32504 PyObject *resultobj = NULL;
32505 wxWindow *arg1 = (wxWindow *) 0 ;
32506 wxToolTip *result;
32507 PyObject * obj0 = 0 ;
32508 char *kwnames[] = {
32509 (char *) "self", NULL
32510 };
32511
32512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32514 if (SWIG_arg_fail(1)) SWIG_fail;
32515 {
32516 PyThreadState* __tstate = wxPyBeginAllowThreads();
32517 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32518
32519 wxPyEndAllowThreads(__tstate);
32520 if (PyErr_Occurred()) SWIG_fail;
32521 }
32522 {
32523 resultobj = wxPyMake_wxObject(result, (bool)0);
32524 }
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32532 PyObject *resultobj = NULL;
32533 wxWindow *arg1 = (wxWindow *) 0 ;
32534 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32535 PyObject * obj0 = 0 ;
32536 PyObject * obj1 = 0 ;
32537 char *kwnames[] = {
32538 (char *) "self",(char *) "dropTarget", NULL
32539 };
32540
32541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32543 if (SWIG_arg_fail(1)) SWIG_fail;
32544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32545 if (SWIG_arg_fail(2)) SWIG_fail;
32546 {
32547 PyThreadState* __tstate = wxPyBeginAllowThreads();
32548 (arg1)->SetDropTarget(arg2);
32549
32550 wxPyEndAllowThreads(__tstate);
32551 if (PyErr_Occurred()) SWIG_fail;
32552 }
32553 Py_INCREF(Py_None); resultobj = Py_None;
32554 return resultobj;
32555 fail:
32556 return NULL;
32557 }
32558
32559
32560 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32561 PyObject *resultobj = NULL;
32562 wxWindow *arg1 = (wxWindow *) 0 ;
32563 wxPyDropTarget *result;
32564 PyObject * obj0 = 0 ;
32565 char *kwnames[] = {
32566 (char *) "self", NULL
32567 };
32568
32569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32571 if (SWIG_arg_fail(1)) SWIG_fail;
32572 {
32573 PyThreadState* __tstate = wxPyBeginAllowThreads();
32574 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32575
32576 wxPyEndAllowThreads(__tstate);
32577 if (PyErr_Occurred()) SWIG_fail;
32578 }
32579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32580 return resultobj;
32581 fail:
32582 return NULL;
32583 }
32584
32585
32586 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32587 PyObject *resultobj = NULL;
32588 wxWindow *arg1 = (wxWindow *) 0 ;
32589 bool arg2 ;
32590 PyObject * obj0 = 0 ;
32591 PyObject * obj1 = 0 ;
32592 char *kwnames[] = {
32593 (char *) "self",(char *) "accept", NULL
32594 };
32595
32596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32598 if (SWIG_arg_fail(1)) SWIG_fail;
32599 {
32600 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32601 if (SWIG_arg_fail(2)) SWIG_fail;
32602 }
32603 {
32604 PyThreadState* __tstate = wxPyBeginAllowThreads();
32605 (arg1)->DragAcceptFiles(arg2);
32606
32607 wxPyEndAllowThreads(__tstate);
32608 if (PyErr_Occurred()) SWIG_fail;
32609 }
32610 Py_INCREF(Py_None); resultobj = Py_None;
32611 return resultobj;
32612 fail:
32613 return NULL;
32614 }
32615
32616
32617 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32618 PyObject *resultobj = NULL;
32619 wxWindow *arg1 = (wxWindow *) 0 ;
32620 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32621 PyObject * obj0 = 0 ;
32622 PyObject * obj1 = 0 ;
32623 char *kwnames[] = {
32624 (char *) "self",(char *) "constraints", NULL
32625 };
32626
32627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32629 if (SWIG_arg_fail(1)) SWIG_fail;
32630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32631 if (SWIG_arg_fail(2)) SWIG_fail;
32632 {
32633 PyThreadState* __tstate = wxPyBeginAllowThreads();
32634 (arg1)->SetConstraints(arg2);
32635
32636 wxPyEndAllowThreads(__tstate);
32637 if (PyErr_Occurred()) SWIG_fail;
32638 }
32639 Py_INCREF(Py_None); resultobj = Py_None;
32640 return resultobj;
32641 fail:
32642 return NULL;
32643 }
32644
32645
32646 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32647 PyObject *resultobj = NULL;
32648 wxWindow *arg1 = (wxWindow *) 0 ;
32649 wxLayoutConstraints *result;
32650 PyObject * obj0 = 0 ;
32651 char *kwnames[] = {
32652 (char *) "self", NULL
32653 };
32654
32655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32657 if (SWIG_arg_fail(1)) SWIG_fail;
32658 {
32659 PyThreadState* __tstate = wxPyBeginAllowThreads();
32660 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32661
32662 wxPyEndAllowThreads(__tstate);
32663 if (PyErr_Occurred()) SWIG_fail;
32664 }
32665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32666 return resultobj;
32667 fail:
32668 return NULL;
32669 }
32670
32671
32672 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32673 PyObject *resultobj = NULL;
32674 wxWindow *arg1 = (wxWindow *) 0 ;
32675 bool arg2 ;
32676 PyObject * obj0 = 0 ;
32677 PyObject * obj1 = 0 ;
32678 char *kwnames[] = {
32679 (char *) "self",(char *) "autoLayout", NULL
32680 };
32681
32682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32684 if (SWIG_arg_fail(1)) SWIG_fail;
32685 {
32686 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32687 if (SWIG_arg_fail(2)) SWIG_fail;
32688 }
32689 {
32690 PyThreadState* __tstate = wxPyBeginAllowThreads();
32691 (arg1)->SetAutoLayout(arg2);
32692
32693 wxPyEndAllowThreads(__tstate);
32694 if (PyErr_Occurred()) SWIG_fail;
32695 }
32696 Py_INCREF(Py_None); resultobj = Py_None;
32697 return resultobj;
32698 fail:
32699 return NULL;
32700 }
32701
32702
32703 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32704 PyObject *resultobj = NULL;
32705 wxWindow *arg1 = (wxWindow *) 0 ;
32706 bool result;
32707 PyObject * obj0 = 0 ;
32708 char *kwnames[] = {
32709 (char *) "self", NULL
32710 };
32711
32712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32714 if (SWIG_arg_fail(1)) SWIG_fail;
32715 {
32716 PyThreadState* __tstate = wxPyBeginAllowThreads();
32717 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32718
32719 wxPyEndAllowThreads(__tstate);
32720 if (PyErr_Occurred()) SWIG_fail;
32721 }
32722 {
32723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32724 }
32725 return resultobj;
32726 fail:
32727 return NULL;
32728 }
32729
32730
32731 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32732 PyObject *resultobj = NULL;
32733 wxWindow *arg1 = (wxWindow *) 0 ;
32734 bool result;
32735 PyObject * obj0 = 0 ;
32736 char *kwnames[] = {
32737 (char *) "self", NULL
32738 };
32739
32740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32742 if (SWIG_arg_fail(1)) SWIG_fail;
32743 {
32744 PyThreadState* __tstate = wxPyBeginAllowThreads();
32745 result = (bool)(arg1)->Layout();
32746
32747 wxPyEndAllowThreads(__tstate);
32748 if (PyErr_Occurred()) SWIG_fail;
32749 }
32750 {
32751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32752 }
32753 return resultobj;
32754 fail:
32755 return NULL;
32756 }
32757
32758
32759 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32760 PyObject *resultobj = NULL;
32761 wxWindow *arg1 = (wxWindow *) 0 ;
32762 wxSizer *arg2 = (wxSizer *) 0 ;
32763 bool arg3 = (bool) true ;
32764 PyObject * obj0 = 0 ;
32765 PyObject * obj1 = 0 ;
32766 PyObject * obj2 = 0 ;
32767 char *kwnames[] = {
32768 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32769 };
32770
32771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32773 if (SWIG_arg_fail(1)) SWIG_fail;
32774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32775 if (SWIG_arg_fail(2)) SWIG_fail;
32776 if (obj2) {
32777 {
32778 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32779 if (SWIG_arg_fail(3)) SWIG_fail;
32780 }
32781 }
32782 {
32783 PyThreadState* __tstate = wxPyBeginAllowThreads();
32784 (arg1)->SetSizer(arg2,arg3);
32785
32786 wxPyEndAllowThreads(__tstate);
32787 if (PyErr_Occurred()) SWIG_fail;
32788 }
32789 Py_INCREF(Py_None); resultobj = Py_None;
32790 return resultobj;
32791 fail:
32792 return NULL;
32793 }
32794
32795
32796 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32797 PyObject *resultobj = NULL;
32798 wxWindow *arg1 = (wxWindow *) 0 ;
32799 wxSizer *arg2 = (wxSizer *) 0 ;
32800 bool arg3 = (bool) true ;
32801 PyObject * obj0 = 0 ;
32802 PyObject * obj1 = 0 ;
32803 PyObject * obj2 = 0 ;
32804 char *kwnames[] = {
32805 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32806 };
32807
32808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32810 if (SWIG_arg_fail(1)) SWIG_fail;
32811 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32812 if (SWIG_arg_fail(2)) SWIG_fail;
32813 if (obj2) {
32814 {
32815 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32816 if (SWIG_arg_fail(3)) SWIG_fail;
32817 }
32818 }
32819 {
32820 PyThreadState* __tstate = wxPyBeginAllowThreads();
32821 (arg1)->SetSizerAndFit(arg2,arg3);
32822
32823 wxPyEndAllowThreads(__tstate);
32824 if (PyErr_Occurred()) SWIG_fail;
32825 }
32826 Py_INCREF(Py_None); resultobj = Py_None;
32827 return resultobj;
32828 fail:
32829 return NULL;
32830 }
32831
32832
32833 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32834 PyObject *resultobj = NULL;
32835 wxWindow *arg1 = (wxWindow *) 0 ;
32836 wxSizer *result;
32837 PyObject * obj0 = 0 ;
32838 char *kwnames[] = {
32839 (char *) "self", NULL
32840 };
32841
32842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32844 if (SWIG_arg_fail(1)) SWIG_fail;
32845 {
32846 PyThreadState* __tstate = wxPyBeginAllowThreads();
32847 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32848
32849 wxPyEndAllowThreads(__tstate);
32850 if (PyErr_Occurred()) SWIG_fail;
32851 }
32852 {
32853 resultobj = wxPyMake_wxObject(result, (bool)0);
32854 }
32855 return resultobj;
32856 fail:
32857 return NULL;
32858 }
32859
32860
32861 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32862 PyObject *resultobj = NULL;
32863 wxWindow *arg1 = (wxWindow *) 0 ;
32864 wxSizer *arg2 = (wxSizer *) 0 ;
32865 PyObject * obj0 = 0 ;
32866 PyObject * obj1 = 0 ;
32867 char *kwnames[] = {
32868 (char *) "self",(char *) "sizer", NULL
32869 };
32870
32871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32873 if (SWIG_arg_fail(1)) SWIG_fail;
32874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32875 if (SWIG_arg_fail(2)) SWIG_fail;
32876 {
32877 PyThreadState* __tstate = wxPyBeginAllowThreads();
32878 (arg1)->SetContainingSizer(arg2);
32879
32880 wxPyEndAllowThreads(__tstate);
32881 if (PyErr_Occurred()) SWIG_fail;
32882 }
32883 Py_INCREF(Py_None); resultobj = Py_None;
32884 return resultobj;
32885 fail:
32886 return NULL;
32887 }
32888
32889
32890 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32891 PyObject *resultobj = NULL;
32892 wxWindow *arg1 = (wxWindow *) 0 ;
32893 wxSizer *result;
32894 PyObject * obj0 = 0 ;
32895 char *kwnames[] = {
32896 (char *) "self", NULL
32897 };
32898
32899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32901 if (SWIG_arg_fail(1)) SWIG_fail;
32902 {
32903 PyThreadState* __tstate = wxPyBeginAllowThreads();
32904 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32905
32906 wxPyEndAllowThreads(__tstate);
32907 if (PyErr_Occurred()) SWIG_fail;
32908 }
32909 {
32910 resultobj = wxPyMake_wxObject(result, (bool)0);
32911 }
32912 return resultobj;
32913 fail:
32914 return NULL;
32915 }
32916
32917
32918 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32919 PyObject *resultobj = NULL;
32920 wxWindow *arg1 = (wxWindow *) 0 ;
32921 PyObject * obj0 = 0 ;
32922 char *kwnames[] = {
32923 (char *) "self", NULL
32924 };
32925
32926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32928 if (SWIG_arg_fail(1)) SWIG_fail;
32929 {
32930 PyThreadState* __tstate = wxPyBeginAllowThreads();
32931 (arg1)->InheritAttributes();
32932
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 Py_INCREF(Py_None); resultobj = Py_None;
32937 return resultobj;
32938 fail:
32939 return NULL;
32940 }
32941
32942
32943 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32944 PyObject *resultobj = NULL;
32945 wxWindow *arg1 = (wxWindow *) 0 ;
32946 bool result;
32947 PyObject * obj0 = 0 ;
32948 char *kwnames[] = {
32949 (char *) "self", NULL
32950 };
32951
32952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32954 if (SWIG_arg_fail(1)) SWIG_fail;
32955 {
32956 PyThreadState* __tstate = wxPyBeginAllowThreads();
32957 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32958
32959 wxPyEndAllowThreads(__tstate);
32960 if (PyErr_Occurred()) SWIG_fail;
32961 }
32962 {
32963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32964 }
32965 return resultobj;
32966 fail:
32967 return NULL;
32968 }
32969
32970
32971 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32972 PyObject *obj;
32973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32974 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32975 Py_INCREF(obj);
32976 return Py_BuildValue((char *)"");
32977 }
32978 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32979 PyObject *resultobj = NULL;
32980 long arg1 ;
32981 wxWindow *arg2 = (wxWindow *) NULL ;
32982 wxWindow *result;
32983 PyObject * obj0 = 0 ;
32984 PyObject * obj1 = 0 ;
32985 char *kwnames[] = {
32986 (char *) "id",(char *) "parent", NULL
32987 };
32988
32989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32990 {
32991 arg1 = static_cast<long >(SWIG_As_long(obj0));
32992 if (SWIG_arg_fail(1)) SWIG_fail;
32993 }
32994 if (obj1) {
32995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32996 if (SWIG_arg_fail(2)) SWIG_fail;
32997 }
32998 {
32999 if (!wxPyCheckForApp()) SWIG_fail;
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
33002
33003 wxPyEndAllowThreads(__tstate);
33004 if (PyErr_Occurred()) SWIG_fail;
33005 }
33006 {
33007 resultobj = wxPyMake_wxObject(result, 0);
33008 }
33009 return resultobj;
33010 fail:
33011 return NULL;
33012 }
33013
33014
33015 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
33016 PyObject *resultobj = NULL;
33017 wxString *arg1 = 0 ;
33018 wxWindow *arg2 = (wxWindow *) NULL ;
33019 wxWindow *result;
33020 bool temp1 = false ;
33021 PyObject * obj0 = 0 ;
33022 PyObject * obj1 = 0 ;
33023 char *kwnames[] = {
33024 (char *) "name",(char *) "parent", NULL
33025 };
33026
33027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
33028 {
33029 arg1 = wxString_in_helper(obj0);
33030 if (arg1 == NULL) SWIG_fail;
33031 temp1 = true;
33032 }
33033 if (obj1) {
33034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33035 if (SWIG_arg_fail(2)) SWIG_fail;
33036 }
33037 {
33038 if (!wxPyCheckForApp()) SWIG_fail;
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
33041
33042 wxPyEndAllowThreads(__tstate);
33043 if (PyErr_Occurred()) SWIG_fail;
33044 }
33045 {
33046 resultobj = wxPyMake_wxObject(result, 0);
33047 }
33048 {
33049 if (temp1)
33050 delete arg1;
33051 }
33052 return resultobj;
33053 fail:
33054 {
33055 if (temp1)
33056 delete arg1;
33057 }
33058 return NULL;
33059 }
33060
33061
33062 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33063 PyObject *resultobj = NULL;
33064 wxString *arg1 = 0 ;
33065 wxWindow *arg2 = (wxWindow *) NULL ;
33066 wxWindow *result;
33067 bool temp1 = false ;
33068 PyObject * obj0 = 0 ;
33069 PyObject * obj1 = 0 ;
33070 char *kwnames[] = {
33071 (char *) "label",(char *) "parent", NULL
33072 };
33073
33074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33075 {
33076 arg1 = wxString_in_helper(obj0);
33077 if (arg1 == NULL) SWIG_fail;
33078 temp1 = true;
33079 }
33080 if (obj1) {
33081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33082 if (SWIG_arg_fail(2)) SWIG_fail;
33083 }
33084 {
33085 if (!wxPyCheckForApp()) SWIG_fail;
33086 PyThreadState* __tstate = wxPyBeginAllowThreads();
33087 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33088
33089 wxPyEndAllowThreads(__tstate);
33090 if (PyErr_Occurred()) SWIG_fail;
33091 }
33092 {
33093 resultobj = wxPyMake_wxObject(result, 0);
33094 }
33095 {
33096 if (temp1)
33097 delete arg1;
33098 }
33099 return resultobj;
33100 fail:
33101 {
33102 if (temp1)
33103 delete arg1;
33104 }
33105 return NULL;
33106 }
33107
33108
33109 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33110 PyObject *resultobj = NULL;
33111 wxWindow *arg1 = (wxWindow *) 0 ;
33112 unsigned long arg2 ;
33113 wxWindow *result;
33114 PyObject * obj0 = 0 ;
33115 PyObject * obj1 = 0 ;
33116 char *kwnames[] = {
33117 (char *) "parent",(char *) "_hWnd", NULL
33118 };
33119
33120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33122 if (SWIG_arg_fail(1)) SWIG_fail;
33123 {
33124 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33125 if (SWIG_arg_fail(2)) SWIG_fail;
33126 }
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33130
33131 wxPyEndAllowThreads(__tstate);
33132 if (PyErr_Occurred()) SWIG_fail;
33133 }
33134 {
33135 resultobj = wxPyMake_wxObject(result, 0);
33136 }
33137 return resultobj;
33138 fail:
33139 return NULL;
33140 }
33141
33142
33143 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33144 PyObject *resultobj = NULL;
33145 PyObject *result;
33146 char *kwnames[] = {
33147 NULL
33148 };
33149
33150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33151 {
33152 PyThreadState* __tstate = wxPyBeginAllowThreads();
33153 result = (PyObject *)GetTopLevelWindows();
33154
33155 wxPyEndAllowThreads(__tstate);
33156 if (PyErr_Occurred()) SWIG_fail;
33157 }
33158 resultobj = result;
33159 return resultobj;
33160 fail:
33161 return NULL;
33162 }
33163
33164
33165 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33166 PyObject *resultobj = NULL;
33167 wxValidator *result;
33168 char *kwnames[] = {
33169 NULL
33170 };
33171
33172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (wxValidator *)new wxValidator();
33176
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33181 return resultobj;
33182 fail:
33183 return NULL;
33184 }
33185
33186
33187 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33188 PyObject *resultobj = NULL;
33189 wxValidator *arg1 = (wxValidator *) 0 ;
33190 wxValidator *result;
33191 PyObject * obj0 = 0 ;
33192 char *kwnames[] = {
33193 (char *) "self", NULL
33194 };
33195
33196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33198 if (SWIG_arg_fail(1)) SWIG_fail;
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 result = (wxValidator *)(arg1)->Clone();
33202
33203 wxPyEndAllowThreads(__tstate);
33204 if (PyErr_Occurred()) SWIG_fail;
33205 }
33206 {
33207 resultobj = wxPyMake_wxObject(result, 0);
33208 }
33209 return resultobj;
33210 fail:
33211 return NULL;
33212 }
33213
33214
33215 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33216 PyObject *resultobj = NULL;
33217 wxValidator *arg1 = (wxValidator *) 0 ;
33218 wxWindow *arg2 = (wxWindow *) 0 ;
33219 bool result;
33220 PyObject * obj0 = 0 ;
33221 PyObject * obj1 = 0 ;
33222 char *kwnames[] = {
33223 (char *) "self",(char *) "parent", NULL
33224 };
33225
33226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33228 if (SWIG_arg_fail(1)) SWIG_fail;
33229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33230 if (SWIG_arg_fail(2)) SWIG_fail;
33231 {
33232 PyThreadState* __tstate = wxPyBeginAllowThreads();
33233 result = (bool)(arg1)->Validate(arg2);
33234
33235 wxPyEndAllowThreads(__tstate);
33236 if (PyErr_Occurred()) SWIG_fail;
33237 }
33238 {
33239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33240 }
33241 return resultobj;
33242 fail:
33243 return NULL;
33244 }
33245
33246
33247 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33248 PyObject *resultobj = NULL;
33249 wxValidator *arg1 = (wxValidator *) 0 ;
33250 bool result;
33251 PyObject * obj0 = 0 ;
33252 char *kwnames[] = {
33253 (char *) "self", NULL
33254 };
33255
33256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33258 if (SWIG_arg_fail(1)) SWIG_fail;
33259 {
33260 PyThreadState* __tstate = wxPyBeginAllowThreads();
33261 result = (bool)(arg1)->TransferToWindow();
33262
33263 wxPyEndAllowThreads(__tstate);
33264 if (PyErr_Occurred()) SWIG_fail;
33265 }
33266 {
33267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33268 }
33269 return resultobj;
33270 fail:
33271 return NULL;
33272 }
33273
33274
33275 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33276 PyObject *resultobj = NULL;
33277 wxValidator *arg1 = (wxValidator *) 0 ;
33278 bool result;
33279 PyObject * obj0 = 0 ;
33280 char *kwnames[] = {
33281 (char *) "self", NULL
33282 };
33283
33284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33286 if (SWIG_arg_fail(1)) SWIG_fail;
33287 {
33288 PyThreadState* __tstate = wxPyBeginAllowThreads();
33289 result = (bool)(arg1)->TransferFromWindow();
33290
33291 wxPyEndAllowThreads(__tstate);
33292 if (PyErr_Occurred()) SWIG_fail;
33293 }
33294 {
33295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33296 }
33297 return resultobj;
33298 fail:
33299 return NULL;
33300 }
33301
33302
33303 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33304 PyObject *resultobj = NULL;
33305 wxValidator *arg1 = (wxValidator *) 0 ;
33306 wxWindow *result;
33307 PyObject * obj0 = 0 ;
33308 char *kwnames[] = {
33309 (char *) "self", NULL
33310 };
33311
33312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33314 if (SWIG_arg_fail(1)) SWIG_fail;
33315 {
33316 PyThreadState* __tstate = wxPyBeginAllowThreads();
33317 result = (wxWindow *)(arg1)->GetWindow();
33318
33319 wxPyEndAllowThreads(__tstate);
33320 if (PyErr_Occurred()) SWIG_fail;
33321 }
33322 {
33323 resultobj = wxPyMake_wxObject(result, 0);
33324 }
33325 return resultobj;
33326 fail:
33327 return NULL;
33328 }
33329
33330
33331 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33332 PyObject *resultobj = NULL;
33333 wxValidator *arg1 = (wxValidator *) 0 ;
33334 wxWindow *arg2 = (wxWindow *) 0 ;
33335 PyObject * obj0 = 0 ;
33336 PyObject * obj1 = 0 ;
33337 char *kwnames[] = {
33338 (char *) "self",(char *) "window", NULL
33339 };
33340
33341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33343 if (SWIG_arg_fail(1)) SWIG_fail;
33344 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33345 if (SWIG_arg_fail(2)) SWIG_fail;
33346 {
33347 PyThreadState* __tstate = wxPyBeginAllowThreads();
33348 (arg1)->SetWindow(arg2);
33349
33350 wxPyEndAllowThreads(__tstate);
33351 if (PyErr_Occurred()) SWIG_fail;
33352 }
33353 Py_INCREF(Py_None); resultobj = Py_None;
33354 return resultobj;
33355 fail:
33356 return NULL;
33357 }
33358
33359
33360 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33361 PyObject *resultobj = NULL;
33362 bool result;
33363 char *kwnames[] = {
33364 NULL
33365 };
33366
33367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33368 {
33369 PyThreadState* __tstate = wxPyBeginAllowThreads();
33370 result = (bool)wxValidator::IsSilent();
33371
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 {
33376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33377 }
33378 return resultobj;
33379 fail:
33380 return NULL;
33381 }
33382
33383
33384 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33385 PyObject *resultobj = NULL;
33386 int arg1 = (int) true ;
33387 PyObject * obj0 = 0 ;
33388 char *kwnames[] = {
33389 (char *) "doIt", NULL
33390 };
33391
33392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33393 if (obj0) {
33394 {
33395 arg1 = static_cast<int >(SWIG_As_int(obj0));
33396 if (SWIG_arg_fail(1)) SWIG_fail;
33397 }
33398 }
33399 {
33400 PyThreadState* __tstate = wxPyBeginAllowThreads();
33401 wxValidator::SetBellOnError(arg1);
33402
33403 wxPyEndAllowThreads(__tstate);
33404 if (PyErr_Occurred()) SWIG_fail;
33405 }
33406 Py_INCREF(Py_None); resultobj = Py_None;
33407 return resultobj;
33408 fail:
33409 return NULL;
33410 }
33411
33412
33413 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33414 PyObject *obj;
33415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33416 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33417 Py_INCREF(obj);
33418 return Py_BuildValue((char *)"");
33419 }
33420 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33421 PyObject *resultobj = NULL;
33422 wxPyValidator *result;
33423 char *kwnames[] = {
33424 NULL
33425 };
33426
33427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33428 {
33429 PyThreadState* __tstate = wxPyBeginAllowThreads();
33430 result = (wxPyValidator *)new wxPyValidator();
33431
33432 wxPyEndAllowThreads(__tstate);
33433 if (PyErr_Occurred()) SWIG_fail;
33434 }
33435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33436 return resultobj;
33437 fail:
33438 return NULL;
33439 }
33440
33441
33442 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33443 PyObject *resultobj = NULL;
33444 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33445 PyObject *arg2 = (PyObject *) 0 ;
33446 PyObject *arg3 = (PyObject *) 0 ;
33447 int arg4 = (int) true ;
33448 PyObject * obj0 = 0 ;
33449 PyObject * obj1 = 0 ;
33450 PyObject * obj2 = 0 ;
33451 PyObject * obj3 = 0 ;
33452 char *kwnames[] = {
33453 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33454 };
33455
33456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33458 if (SWIG_arg_fail(1)) SWIG_fail;
33459 arg2 = obj1;
33460 arg3 = obj2;
33461 if (obj3) {
33462 {
33463 arg4 = static_cast<int >(SWIG_As_int(obj3));
33464 if (SWIG_arg_fail(4)) SWIG_fail;
33465 }
33466 }
33467 {
33468 PyThreadState* __tstate = wxPyBeginAllowThreads();
33469 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33470
33471 wxPyEndAllowThreads(__tstate);
33472 if (PyErr_Occurred()) SWIG_fail;
33473 }
33474 Py_INCREF(Py_None); resultobj = Py_None;
33475 return resultobj;
33476 fail:
33477 return NULL;
33478 }
33479
33480
33481 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33482 PyObject *obj;
33483 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33484 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33485 Py_INCREF(obj);
33486 return Py_BuildValue((char *)"");
33487 }
33488 static int _wrap_DefaultValidator_set(PyObject *) {
33489 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33490 return 1;
33491 }
33492
33493
33494 static PyObject *_wrap_DefaultValidator_get(void) {
33495 PyObject *pyobj = NULL;
33496
33497 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33498 return pyobj;
33499 }
33500
33501
33502 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33503 PyObject *resultobj = NULL;
33504 wxString const &arg1_defvalue = wxPyEmptyString ;
33505 wxString *arg1 = (wxString *) &arg1_defvalue ;
33506 long arg2 = (long) 0 ;
33507 wxMenu *result;
33508 bool temp1 = false ;
33509 PyObject * obj0 = 0 ;
33510 PyObject * obj1 = 0 ;
33511 char *kwnames[] = {
33512 (char *) "title",(char *) "style", NULL
33513 };
33514
33515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33516 if (obj0) {
33517 {
33518 arg1 = wxString_in_helper(obj0);
33519 if (arg1 == NULL) SWIG_fail;
33520 temp1 = true;
33521 }
33522 }
33523 if (obj1) {
33524 {
33525 arg2 = static_cast<long >(SWIG_As_long(obj1));
33526 if (SWIG_arg_fail(2)) SWIG_fail;
33527 }
33528 }
33529 {
33530 if (!wxPyCheckForApp()) SWIG_fail;
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33533
33534 wxPyEndAllowThreads(__tstate);
33535 if (PyErr_Occurred()) SWIG_fail;
33536 }
33537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33538 {
33539 if (temp1)
33540 delete arg1;
33541 }
33542 return resultobj;
33543 fail:
33544 {
33545 if (temp1)
33546 delete arg1;
33547 }
33548 return NULL;
33549 }
33550
33551
33552 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33553 PyObject *resultobj = NULL;
33554 wxMenu *arg1 = (wxMenu *) 0 ;
33555 int arg2 ;
33556 wxString *arg3 = 0 ;
33557 wxString const &arg4_defvalue = wxPyEmptyString ;
33558 wxString *arg4 = (wxString *) &arg4_defvalue ;
33559 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33560 wxMenuItem *result;
33561 bool temp3 = false ;
33562 bool temp4 = false ;
33563 PyObject * obj0 = 0 ;
33564 PyObject * obj1 = 0 ;
33565 PyObject * obj2 = 0 ;
33566 PyObject * obj3 = 0 ;
33567 PyObject * obj4 = 0 ;
33568 char *kwnames[] = {
33569 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33570 };
33571
33572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33574 if (SWIG_arg_fail(1)) SWIG_fail;
33575 {
33576 arg2 = static_cast<int >(SWIG_As_int(obj1));
33577 if (SWIG_arg_fail(2)) SWIG_fail;
33578 }
33579 {
33580 arg3 = wxString_in_helper(obj2);
33581 if (arg3 == NULL) SWIG_fail;
33582 temp3 = true;
33583 }
33584 if (obj3) {
33585 {
33586 arg4 = wxString_in_helper(obj3);
33587 if (arg4 == NULL) SWIG_fail;
33588 temp4 = true;
33589 }
33590 }
33591 if (obj4) {
33592 {
33593 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33594 if (SWIG_arg_fail(5)) SWIG_fail;
33595 }
33596 }
33597 {
33598 PyThreadState* __tstate = wxPyBeginAllowThreads();
33599 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33600
33601 wxPyEndAllowThreads(__tstate);
33602 if (PyErr_Occurred()) SWIG_fail;
33603 }
33604 {
33605 resultobj = wxPyMake_wxObject(result, (bool)0);
33606 }
33607 {
33608 if (temp3)
33609 delete arg3;
33610 }
33611 {
33612 if (temp4)
33613 delete arg4;
33614 }
33615 return resultobj;
33616 fail:
33617 {
33618 if (temp3)
33619 delete arg3;
33620 }
33621 {
33622 if (temp4)
33623 delete arg4;
33624 }
33625 return NULL;
33626 }
33627
33628
33629 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33630 PyObject *resultobj = NULL;
33631 wxMenu *arg1 = (wxMenu *) 0 ;
33632 wxMenuItem *result;
33633 PyObject * obj0 = 0 ;
33634 char *kwnames[] = {
33635 (char *) "self", NULL
33636 };
33637
33638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33640 if (SWIG_arg_fail(1)) SWIG_fail;
33641 {
33642 PyThreadState* __tstate = wxPyBeginAllowThreads();
33643 result = (wxMenuItem *)(arg1)->AppendSeparator();
33644
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 {
33649 resultobj = wxPyMake_wxObject(result, (bool)0);
33650 }
33651 return resultobj;
33652 fail:
33653 return NULL;
33654 }
33655
33656
33657 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33658 PyObject *resultobj = NULL;
33659 wxMenu *arg1 = (wxMenu *) 0 ;
33660 int arg2 ;
33661 wxString *arg3 = 0 ;
33662 wxString const &arg4_defvalue = wxPyEmptyString ;
33663 wxString *arg4 = (wxString *) &arg4_defvalue ;
33664 wxMenuItem *result;
33665 bool temp3 = false ;
33666 bool temp4 = false ;
33667 PyObject * obj0 = 0 ;
33668 PyObject * obj1 = 0 ;
33669 PyObject * obj2 = 0 ;
33670 PyObject * obj3 = 0 ;
33671 char *kwnames[] = {
33672 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33673 };
33674
33675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33677 if (SWIG_arg_fail(1)) SWIG_fail;
33678 {
33679 arg2 = static_cast<int >(SWIG_As_int(obj1));
33680 if (SWIG_arg_fail(2)) SWIG_fail;
33681 }
33682 {
33683 arg3 = wxString_in_helper(obj2);
33684 if (arg3 == NULL) SWIG_fail;
33685 temp3 = true;
33686 }
33687 if (obj3) {
33688 {
33689 arg4 = wxString_in_helper(obj3);
33690 if (arg4 == NULL) SWIG_fail;
33691 temp4 = true;
33692 }
33693 }
33694 {
33695 PyThreadState* __tstate = wxPyBeginAllowThreads();
33696 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33697
33698 wxPyEndAllowThreads(__tstate);
33699 if (PyErr_Occurred()) SWIG_fail;
33700 }
33701 {
33702 resultobj = wxPyMake_wxObject(result, (bool)0);
33703 }
33704 {
33705 if (temp3)
33706 delete arg3;
33707 }
33708 {
33709 if (temp4)
33710 delete arg4;
33711 }
33712 return resultobj;
33713 fail:
33714 {
33715 if (temp3)
33716 delete arg3;
33717 }
33718 {
33719 if (temp4)
33720 delete arg4;
33721 }
33722 return NULL;
33723 }
33724
33725
33726 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33727 PyObject *resultobj = NULL;
33728 wxMenu *arg1 = (wxMenu *) 0 ;
33729 int arg2 ;
33730 wxString *arg3 = 0 ;
33731 wxString const &arg4_defvalue = wxPyEmptyString ;
33732 wxString *arg4 = (wxString *) &arg4_defvalue ;
33733 wxMenuItem *result;
33734 bool temp3 = false ;
33735 bool temp4 = false ;
33736 PyObject * obj0 = 0 ;
33737 PyObject * obj1 = 0 ;
33738 PyObject * obj2 = 0 ;
33739 PyObject * obj3 = 0 ;
33740 char *kwnames[] = {
33741 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33742 };
33743
33744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33746 if (SWIG_arg_fail(1)) SWIG_fail;
33747 {
33748 arg2 = static_cast<int >(SWIG_As_int(obj1));
33749 if (SWIG_arg_fail(2)) SWIG_fail;
33750 }
33751 {
33752 arg3 = wxString_in_helper(obj2);
33753 if (arg3 == NULL) SWIG_fail;
33754 temp3 = true;
33755 }
33756 if (obj3) {
33757 {
33758 arg4 = wxString_in_helper(obj3);
33759 if (arg4 == NULL) SWIG_fail;
33760 temp4 = true;
33761 }
33762 }
33763 {
33764 PyThreadState* __tstate = wxPyBeginAllowThreads();
33765 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33766
33767 wxPyEndAllowThreads(__tstate);
33768 if (PyErr_Occurred()) SWIG_fail;
33769 }
33770 {
33771 resultobj = wxPyMake_wxObject(result, (bool)0);
33772 }
33773 {
33774 if (temp3)
33775 delete arg3;
33776 }
33777 {
33778 if (temp4)
33779 delete arg4;
33780 }
33781 return resultobj;
33782 fail:
33783 {
33784 if (temp3)
33785 delete arg3;
33786 }
33787 {
33788 if (temp4)
33789 delete arg4;
33790 }
33791 return NULL;
33792 }
33793
33794
33795 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33796 PyObject *resultobj = NULL;
33797 wxMenu *arg1 = (wxMenu *) 0 ;
33798 int arg2 ;
33799 wxString *arg3 = 0 ;
33800 wxMenu *arg4 = (wxMenu *) 0 ;
33801 wxString const &arg5_defvalue = wxPyEmptyString ;
33802 wxString *arg5 = (wxString *) &arg5_defvalue ;
33803 wxMenuItem *result;
33804 bool temp3 = false ;
33805 bool temp5 = false ;
33806 PyObject * obj0 = 0 ;
33807 PyObject * obj1 = 0 ;
33808 PyObject * obj2 = 0 ;
33809 PyObject * obj3 = 0 ;
33810 PyObject * obj4 = 0 ;
33811 char *kwnames[] = {
33812 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33813 };
33814
33815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33817 if (SWIG_arg_fail(1)) SWIG_fail;
33818 {
33819 arg2 = static_cast<int >(SWIG_As_int(obj1));
33820 if (SWIG_arg_fail(2)) SWIG_fail;
33821 }
33822 {
33823 arg3 = wxString_in_helper(obj2);
33824 if (arg3 == NULL) SWIG_fail;
33825 temp3 = true;
33826 }
33827 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33828 if (SWIG_arg_fail(4)) SWIG_fail;
33829 if (obj4) {
33830 {
33831 arg5 = wxString_in_helper(obj4);
33832 if (arg5 == NULL) SWIG_fail;
33833 temp5 = true;
33834 }
33835 }
33836 {
33837 PyThreadState* __tstate = wxPyBeginAllowThreads();
33838 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33839
33840 wxPyEndAllowThreads(__tstate);
33841 if (PyErr_Occurred()) SWIG_fail;
33842 }
33843 {
33844 resultobj = wxPyMake_wxObject(result, (bool)0);
33845 }
33846 {
33847 if (temp3)
33848 delete arg3;
33849 }
33850 {
33851 if (temp5)
33852 delete arg5;
33853 }
33854 return resultobj;
33855 fail:
33856 {
33857 if (temp3)
33858 delete arg3;
33859 }
33860 {
33861 if (temp5)
33862 delete arg5;
33863 }
33864 return NULL;
33865 }
33866
33867
33868 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33869 PyObject *resultobj = NULL;
33870 wxMenu *arg1 = (wxMenu *) 0 ;
33871 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33872 wxMenuItem *result;
33873 PyObject * obj0 = 0 ;
33874 PyObject * obj1 = 0 ;
33875 char *kwnames[] = {
33876 (char *) "self",(char *) "item", NULL
33877 };
33878
33879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33881 if (SWIG_arg_fail(1)) SWIG_fail;
33882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33883 if (SWIG_arg_fail(2)) SWIG_fail;
33884 {
33885 PyThreadState* __tstate = wxPyBeginAllowThreads();
33886 result = (wxMenuItem *)(arg1)->Append(arg2);
33887
33888 wxPyEndAllowThreads(__tstate);
33889 if (PyErr_Occurred()) SWIG_fail;
33890 }
33891 {
33892 resultobj = wxPyMake_wxObject(result, (bool)0);
33893 }
33894 return resultobj;
33895 fail:
33896 return NULL;
33897 }
33898
33899
33900 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33901 PyObject *resultobj = NULL;
33902 wxMenu *arg1 = (wxMenu *) 0 ;
33903 PyObject * obj0 = 0 ;
33904 char *kwnames[] = {
33905 (char *) "self", NULL
33906 };
33907
33908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33910 if (SWIG_arg_fail(1)) SWIG_fail;
33911 {
33912 PyThreadState* __tstate = wxPyBeginAllowThreads();
33913 (arg1)->Break();
33914
33915 wxPyEndAllowThreads(__tstate);
33916 if (PyErr_Occurred()) SWIG_fail;
33917 }
33918 Py_INCREF(Py_None); resultobj = Py_None;
33919 return resultobj;
33920 fail:
33921 return NULL;
33922 }
33923
33924
33925 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33926 PyObject *resultobj = NULL;
33927 wxMenu *arg1 = (wxMenu *) 0 ;
33928 size_t arg2 ;
33929 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33930 wxMenuItem *result;
33931 PyObject * obj0 = 0 ;
33932 PyObject * obj1 = 0 ;
33933 PyObject * obj2 = 0 ;
33934 char *kwnames[] = {
33935 (char *) "self",(char *) "pos",(char *) "item", NULL
33936 };
33937
33938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33940 if (SWIG_arg_fail(1)) SWIG_fail;
33941 {
33942 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33943 if (SWIG_arg_fail(2)) SWIG_fail;
33944 }
33945 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33946 if (SWIG_arg_fail(3)) SWIG_fail;
33947 {
33948 PyThreadState* __tstate = wxPyBeginAllowThreads();
33949 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33950
33951 wxPyEndAllowThreads(__tstate);
33952 if (PyErr_Occurred()) SWIG_fail;
33953 }
33954 {
33955 resultobj = wxPyMake_wxObject(result, (bool)0);
33956 }
33957 return resultobj;
33958 fail:
33959 return NULL;
33960 }
33961
33962
33963 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33964 PyObject *resultobj = NULL;
33965 wxMenu *arg1 = (wxMenu *) 0 ;
33966 size_t arg2 ;
33967 int arg3 ;
33968 wxString *arg4 = 0 ;
33969 wxString const &arg5_defvalue = wxPyEmptyString ;
33970 wxString *arg5 = (wxString *) &arg5_defvalue ;
33971 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33972 wxMenuItem *result;
33973 bool temp4 = false ;
33974 bool temp5 = false ;
33975 PyObject * obj0 = 0 ;
33976 PyObject * obj1 = 0 ;
33977 PyObject * obj2 = 0 ;
33978 PyObject * obj3 = 0 ;
33979 PyObject * obj4 = 0 ;
33980 PyObject * obj5 = 0 ;
33981 char *kwnames[] = {
33982 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33983 };
33984
33985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33987 if (SWIG_arg_fail(1)) SWIG_fail;
33988 {
33989 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33990 if (SWIG_arg_fail(2)) SWIG_fail;
33991 }
33992 {
33993 arg3 = static_cast<int >(SWIG_As_int(obj2));
33994 if (SWIG_arg_fail(3)) SWIG_fail;
33995 }
33996 {
33997 arg4 = wxString_in_helper(obj3);
33998 if (arg4 == NULL) SWIG_fail;
33999 temp4 = true;
34000 }
34001 if (obj4) {
34002 {
34003 arg5 = wxString_in_helper(obj4);
34004 if (arg5 == NULL) SWIG_fail;
34005 temp5 = true;
34006 }
34007 }
34008 if (obj5) {
34009 {
34010 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
34011 if (SWIG_arg_fail(6)) SWIG_fail;
34012 }
34013 }
34014 {
34015 PyThreadState* __tstate = wxPyBeginAllowThreads();
34016 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
34017
34018 wxPyEndAllowThreads(__tstate);
34019 if (PyErr_Occurred()) SWIG_fail;
34020 }
34021 {
34022 resultobj = wxPyMake_wxObject(result, (bool)0);
34023 }
34024 {
34025 if (temp4)
34026 delete arg4;
34027 }
34028 {
34029 if (temp5)
34030 delete arg5;
34031 }
34032 return resultobj;
34033 fail:
34034 {
34035 if (temp4)
34036 delete arg4;
34037 }
34038 {
34039 if (temp5)
34040 delete arg5;
34041 }
34042 return NULL;
34043 }
34044
34045
34046 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34047 PyObject *resultobj = NULL;
34048 wxMenu *arg1 = (wxMenu *) 0 ;
34049 size_t arg2 ;
34050 wxMenuItem *result;
34051 PyObject * obj0 = 0 ;
34052 PyObject * obj1 = 0 ;
34053 char *kwnames[] = {
34054 (char *) "self",(char *) "pos", NULL
34055 };
34056
34057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
34058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34059 if (SWIG_arg_fail(1)) SWIG_fail;
34060 {
34061 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34062 if (SWIG_arg_fail(2)) SWIG_fail;
34063 }
34064 {
34065 PyThreadState* __tstate = wxPyBeginAllowThreads();
34066 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
34067
34068 wxPyEndAllowThreads(__tstate);
34069 if (PyErr_Occurred()) SWIG_fail;
34070 }
34071 {
34072 resultobj = wxPyMake_wxObject(result, (bool)0);
34073 }
34074 return resultobj;
34075 fail:
34076 return NULL;
34077 }
34078
34079
34080 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34081 PyObject *resultobj = NULL;
34082 wxMenu *arg1 = (wxMenu *) 0 ;
34083 size_t arg2 ;
34084 int arg3 ;
34085 wxString *arg4 = 0 ;
34086 wxString const &arg5_defvalue = wxPyEmptyString ;
34087 wxString *arg5 = (wxString *) &arg5_defvalue ;
34088 wxMenuItem *result;
34089 bool temp4 = false ;
34090 bool temp5 = false ;
34091 PyObject * obj0 = 0 ;
34092 PyObject * obj1 = 0 ;
34093 PyObject * obj2 = 0 ;
34094 PyObject * obj3 = 0 ;
34095 PyObject * obj4 = 0 ;
34096 char *kwnames[] = {
34097 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34098 };
34099
34100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34102 if (SWIG_arg_fail(1)) SWIG_fail;
34103 {
34104 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34105 if (SWIG_arg_fail(2)) SWIG_fail;
34106 }
34107 {
34108 arg3 = static_cast<int >(SWIG_As_int(obj2));
34109 if (SWIG_arg_fail(3)) SWIG_fail;
34110 }
34111 {
34112 arg4 = wxString_in_helper(obj3);
34113 if (arg4 == NULL) SWIG_fail;
34114 temp4 = true;
34115 }
34116 if (obj4) {
34117 {
34118 arg5 = wxString_in_helper(obj4);
34119 if (arg5 == NULL) SWIG_fail;
34120 temp5 = true;
34121 }
34122 }
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34126
34127 wxPyEndAllowThreads(__tstate);
34128 if (PyErr_Occurred()) SWIG_fail;
34129 }
34130 {
34131 resultobj = wxPyMake_wxObject(result, (bool)0);
34132 }
34133 {
34134 if (temp4)
34135 delete arg4;
34136 }
34137 {
34138 if (temp5)
34139 delete arg5;
34140 }
34141 return resultobj;
34142 fail:
34143 {
34144 if (temp4)
34145 delete arg4;
34146 }
34147 {
34148 if (temp5)
34149 delete arg5;
34150 }
34151 return NULL;
34152 }
34153
34154
34155 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34156 PyObject *resultobj = NULL;
34157 wxMenu *arg1 = (wxMenu *) 0 ;
34158 size_t arg2 ;
34159 int arg3 ;
34160 wxString *arg4 = 0 ;
34161 wxString const &arg5_defvalue = wxPyEmptyString ;
34162 wxString *arg5 = (wxString *) &arg5_defvalue ;
34163 wxMenuItem *result;
34164 bool temp4 = false ;
34165 bool temp5 = false ;
34166 PyObject * obj0 = 0 ;
34167 PyObject * obj1 = 0 ;
34168 PyObject * obj2 = 0 ;
34169 PyObject * obj3 = 0 ;
34170 PyObject * obj4 = 0 ;
34171 char *kwnames[] = {
34172 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34173 };
34174
34175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34177 if (SWIG_arg_fail(1)) SWIG_fail;
34178 {
34179 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34180 if (SWIG_arg_fail(2)) SWIG_fail;
34181 }
34182 {
34183 arg3 = static_cast<int >(SWIG_As_int(obj2));
34184 if (SWIG_arg_fail(3)) SWIG_fail;
34185 }
34186 {
34187 arg4 = wxString_in_helper(obj3);
34188 if (arg4 == NULL) SWIG_fail;
34189 temp4 = true;
34190 }
34191 if (obj4) {
34192 {
34193 arg5 = wxString_in_helper(obj4);
34194 if (arg5 == NULL) SWIG_fail;
34195 temp5 = true;
34196 }
34197 }
34198 {
34199 PyThreadState* __tstate = wxPyBeginAllowThreads();
34200 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34201
34202 wxPyEndAllowThreads(__tstate);
34203 if (PyErr_Occurred()) SWIG_fail;
34204 }
34205 {
34206 resultobj = wxPyMake_wxObject(result, (bool)0);
34207 }
34208 {
34209 if (temp4)
34210 delete arg4;
34211 }
34212 {
34213 if (temp5)
34214 delete arg5;
34215 }
34216 return resultobj;
34217 fail:
34218 {
34219 if (temp4)
34220 delete arg4;
34221 }
34222 {
34223 if (temp5)
34224 delete arg5;
34225 }
34226 return NULL;
34227 }
34228
34229
34230 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34231 PyObject *resultobj = NULL;
34232 wxMenu *arg1 = (wxMenu *) 0 ;
34233 size_t arg2 ;
34234 int arg3 ;
34235 wxString *arg4 = 0 ;
34236 wxMenu *arg5 = (wxMenu *) 0 ;
34237 wxString const &arg6_defvalue = wxPyEmptyString ;
34238 wxString *arg6 = (wxString *) &arg6_defvalue ;
34239 wxMenuItem *result;
34240 bool temp4 = false ;
34241 bool temp6 = false ;
34242 PyObject * obj0 = 0 ;
34243 PyObject * obj1 = 0 ;
34244 PyObject * obj2 = 0 ;
34245 PyObject * obj3 = 0 ;
34246 PyObject * obj4 = 0 ;
34247 PyObject * obj5 = 0 ;
34248 char *kwnames[] = {
34249 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34250 };
34251
34252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34254 if (SWIG_arg_fail(1)) SWIG_fail;
34255 {
34256 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34257 if (SWIG_arg_fail(2)) SWIG_fail;
34258 }
34259 {
34260 arg3 = static_cast<int >(SWIG_As_int(obj2));
34261 if (SWIG_arg_fail(3)) SWIG_fail;
34262 }
34263 {
34264 arg4 = wxString_in_helper(obj3);
34265 if (arg4 == NULL) SWIG_fail;
34266 temp4 = true;
34267 }
34268 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34269 if (SWIG_arg_fail(5)) SWIG_fail;
34270 if (obj5) {
34271 {
34272 arg6 = wxString_in_helper(obj5);
34273 if (arg6 == NULL) SWIG_fail;
34274 temp6 = true;
34275 }
34276 }
34277 {
34278 PyThreadState* __tstate = wxPyBeginAllowThreads();
34279 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34280
34281 wxPyEndAllowThreads(__tstate);
34282 if (PyErr_Occurred()) SWIG_fail;
34283 }
34284 {
34285 resultobj = wxPyMake_wxObject(result, (bool)0);
34286 }
34287 {
34288 if (temp4)
34289 delete arg4;
34290 }
34291 {
34292 if (temp6)
34293 delete arg6;
34294 }
34295 return resultobj;
34296 fail:
34297 {
34298 if (temp4)
34299 delete arg4;
34300 }
34301 {
34302 if (temp6)
34303 delete arg6;
34304 }
34305 return NULL;
34306 }
34307
34308
34309 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34310 PyObject *resultobj = NULL;
34311 wxMenu *arg1 = (wxMenu *) 0 ;
34312 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34313 wxMenuItem *result;
34314 PyObject * obj0 = 0 ;
34315 PyObject * obj1 = 0 ;
34316 char *kwnames[] = {
34317 (char *) "self",(char *) "item", NULL
34318 };
34319
34320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34322 if (SWIG_arg_fail(1)) SWIG_fail;
34323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34324 if (SWIG_arg_fail(2)) SWIG_fail;
34325 {
34326 PyThreadState* __tstate = wxPyBeginAllowThreads();
34327 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34328
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 {
34333 resultobj = wxPyMake_wxObject(result, (bool)0);
34334 }
34335 return resultobj;
34336 fail:
34337 return NULL;
34338 }
34339
34340
34341 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34342 PyObject *resultobj = NULL;
34343 wxMenu *arg1 = (wxMenu *) 0 ;
34344 int arg2 ;
34345 wxString *arg3 = 0 ;
34346 wxString const &arg4_defvalue = wxPyEmptyString ;
34347 wxString *arg4 = (wxString *) &arg4_defvalue ;
34348 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34349 wxMenuItem *result;
34350 bool temp3 = false ;
34351 bool temp4 = false ;
34352 PyObject * obj0 = 0 ;
34353 PyObject * obj1 = 0 ;
34354 PyObject * obj2 = 0 ;
34355 PyObject * obj3 = 0 ;
34356 PyObject * obj4 = 0 ;
34357 char *kwnames[] = {
34358 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34359 };
34360
34361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34363 if (SWIG_arg_fail(1)) SWIG_fail;
34364 {
34365 arg2 = static_cast<int >(SWIG_As_int(obj1));
34366 if (SWIG_arg_fail(2)) SWIG_fail;
34367 }
34368 {
34369 arg3 = wxString_in_helper(obj2);
34370 if (arg3 == NULL) SWIG_fail;
34371 temp3 = true;
34372 }
34373 if (obj3) {
34374 {
34375 arg4 = wxString_in_helper(obj3);
34376 if (arg4 == NULL) SWIG_fail;
34377 temp4 = true;
34378 }
34379 }
34380 if (obj4) {
34381 {
34382 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34383 if (SWIG_arg_fail(5)) SWIG_fail;
34384 }
34385 }
34386 {
34387 PyThreadState* __tstate = wxPyBeginAllowThreads();
34388 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34389
34390 wxPyEndAllowThreads(__tstate);
34391 if (PyErr_Occurred()) SWIG_fail;
34392 }
34393 {
34394 resultobj = wxPyMake_wxObject(result, (bool)0);
34395 }
34396 {
34397 if (temp3)
34398 delete arg3;
34399 }
34400 {
34401 if (temp4)
34402 delete arg4;
34403 }
34404 return resultobj;
34405 fail:
34406 {
34407 if (temp3)
34408 delete arg3;
34409 }
34410 {
34411 if (temp4)
34412 delete arg4;
34413 }
34414 return NULL;
34415 }
34416
34417
34418 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34419 PyObject *resultobj = NULL;
34420 wxMenu *arg1 = (wxMenu *) 0 ;
34421 wxMenuItem *result;
34422 PyObject * obj0 = 0 ;
34423 char *kwnames[] = {
34424 (char *) "self", NULL
34425 };
34426
34427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34429 if (SWIG_arg_fail(1)) SWIG_fail;
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 result = (wxMenuItem *)(arg1)->PrependSeparator();
34433
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 {
34438 resultobj = wxPyMake_wxObject(result, (bool)0);
34439 }
34440 return resultobj;
34441 fail:
34442 return NULL;
34443 }
34444
34445
34446 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34447 PyObject *resultobj = NULL;
34448 wxMenu *arg1 = (wxMenu *) 0 ;
34449 int arg2 ;
34450 wxString *arg3 = 0 ;
34451 wxString const &arg4_defvalue = wxPyEmptyString ;
34452 wxString *arg4 = (wxString *) &arg4_defvalue ;
34453 wxMenuItem *result;
34454 bool temp3 = false ;
34455 bool temp4 = false ;
34456 PyObject * obj0 = 0 ;
34457 PyObject * obj1 = 0 ;
34458 PyObject * obj2 = 0 ;
34459 PyObject * obj3 = 0 ;
34460 char *kwnames[] = {
34461 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34462 };
34463
34464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34466 if (SWIG_arg_fail(1)) SWIG_fail;
34467 {
34468 arg2 = static_cast<int >(SWIG_As_int(obj1));
34469 if (SWIG_arg_fail(2)) SWIG_fail;
34470 }
34471 {
34472 arg3 = wxString_in_helper(obj2);
34473 if (arg3 == NULL) SWIG_fail;
34474 temp3 = true;
34475 }
34476 if (obj3) {
34477 {
34478 arg4 = wxString_in_helper(obj3);
34479 if (arg4 == NULL) SWIG_fail;
34480 temp4 = true;
34481 }
34482 }
34483 {
34484 PyThreadState* __tstate = wxPyBeginAllowThreads();
34485 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34486
34487 wxPyEndAllowThreads(__tstate);
34488 if (PyErr_Occurred()) SWIG_fail;
34489 }
34490 {
34491 resultobj = wxPyMake_wxObject(result, (bool)0);
34492 }
34493 {
34494 if (temp3)
34495 delete arg3;
34496 }
34497 {
34498 if (temp4)
34499 delete arg4;
34500 }
34501 return resultobj;
34502 fail:
34503 {
34504 if (temp3)
34505 delete arg3;
34506 }
34507 {
34508 if (temp4)
34509 delete arg4;
34510 }
34511 return NULL;
34512 }
34513
34514
34515 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34516 PyObject *resultobj = NULL;
34517 wxMenu *arg1 = (wxMenu *) 0 ;
34518 int arg2 ;
34519 wxString *arg3 = 0 ;
34520 wxString const &arg4_defvalue = wxPyEmptyString ;
34521 wxString *arg4 = (wxString *) &arg4_defvalue ;
34522 wxMenuItem *result;
34523 bool temp3 = false ;
34524 bool temp4 = false ;
34525 PyObject * obj0 = 0 ;
34526 PyObject * obj1 = 0 ;
34527 PyObject * obj2 = 0 ;
34528 PyObject * obj3 = 0 ;
34529 char *kwnames[] = {
34530 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34531 };
34532
34533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34535 if (SWIG_arg_fail(1)) SWIG_fail;
34536 {
34537 arg2 = static_cast<int >(SWIG_As_int(obj1));
34538 if (SWIG_arg_fail(2)) SWIG_fail;
34539 }
34540 {
34541 arg3 = wxString_in_helper(obj2);
34542 if (arg3 == NULL) SWIG_fail;
34543 temp3 = true;
34544 }
34545 if (obj3) {
34546 {
34547 arg4 = wxString_in_helper(obj3);
34548 if (arg4 == NULL) SWIG_fail;
34549 temp4 = true;
34550 }
34551 }
34552 {
34553 PyThreadState* __tstate = wxPyBeginAllowThreads();
34554 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34555
34556 wxPyEndAllowThreads(__tstate);
34557 if (PyErr_Occurred()) SWIG_fail;
34558 }
34559 {
34560 resultobj = wxPyMake_wxObject(result, (bool)0);
34561 }
34562 {
34563 if (temp3)
34564 delete arg3;
34565 }
34566 {
34567 if (temp4)
34568 delete arg4;
34569 }
34570 return resultobj;
34571 fail:
34572 {
34573 if (temp3)
34574 delete arg3;
34575 }
34576 {
34577 if (temp4)
34578 delete arg4;
34579 }
34580 return NULL;
34581 }
34582
34583
34584 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34585 PyObject *resultobj = NULL;
34586 wxMenu *arg1 = (wxMenu *) 0 ;
34587 int arg2 ;
34588 wxString *arg3 = 0 ;
34589 wxMenu *arg4 = (wxMenu *) 0 ;
34590 wxString const &arg5_defvalue = wxPyEmptyString ;
34591 wxString *arg5 = (wxString *) &arg5_defvalue ;
34592 wxMenuItem *result;
34593 bool temp3 = false ;
34594 bool temp5 = false ;
34595 PyObject * obj0 = 0 ;
34596 PyObject * obj1 = 0 ;
34597 PyObject * obj2 = 0 ;
34598 PyObject * obj3 = 0 ;
34599 PyObject * obj4 = 0 ;
34600 char *kwnames[] = {
34601 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34602 };
34603
34604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34606 if (SWIG_arg_fail(1)) SWIG_fail;
34607 {
34608 arg2 = static_cast<int >(SWIG_As_int(obj1));
34609 if (SWIG_arg_fail(2)) SWIG_fail;
34610 }
34611 {
34612 arg3 = wxString_in_helper(obj2);
34613 if (arg3 == NULL) SWIG_fail;
34614 temp3 = true;
34615 }
34616 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34617 if (SWIG_arg_fail(4)) SWIG_fail;
34618 if (obj4) {
34619 {
34620 arg5 = wxString_in_helper(obj4);
34621 if (arg5 == NULL) SWIG_fail;
34622 temp5 = true;
34623 }
34624 }
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34628
34629 wxPyEndAllowThreads(__tstate);
34630 if (PyErr_Occurred()) SWIG_fail;
34631 }
34632 {
34633 resultobj = wxPyMake_wxObject(result, (bool)0);
34634 }
34635 {
34636 if (temp3)
34637 delete arg3;
34638 }
34639 {
34640 if (temp5)
34641 delete arg5;
34642 }
34643 return resultobj;
34644 fail:
34645 {
34646 if (temp3)
34647 delete arg3;
34648 }
34649 {
34650 if (temp5)
34651 delete arg5;
34652 }
34653 return NULL;
34654 }
34655
34656
34657 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34658 PyObject *resultobj = NULL;
34659 wxMenu *arg1 = (wxMenu *) 0 ;
34660 int arg2 ;
34661 wxMenuItem *result;
34662 PyObject * obj0 = 0 ;
34663 PyObject * obj1 = 0 ;
34664 char *kwnames[] = {
34665 (char *) "self",(char *) "id", NULL
34666 };
34667
34668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34670 if (SWIG_arg_fail(1)) SWIG_fail;
34671 {
34672 arg2 = static_cast<int >(SWIG_As_int(obj1));
34673 if (SWIG_arg_fail(2)) SWIG_fail;
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 result = (wxMenuItem *)(arg1)->Remove(arg2);
34678
34679 wxPyEndAllowThreads(__tstate);
34680 if (PyErr_Occurred()) SWIG_fail;
34681 }
34682 {
34683 resultobj = wxPyMake_wxObject(result, (bool)0);
34684 }
34685 return resultobj;
34686 fail:
34687 return NULL;
34688 }
34689
34690
34691 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34692 PyObject *resultobj = NULL;
34693 wxMenu *arg1 = (wxMenu *) 0 ;
34694 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34695 wxMenuItem *result;
34696 PyObject * obj0 = 0 ;
34697 PyObject * obj1 = 0 ;
34698 char *kwnames[] = {
34699 (char *) "self",(char *) "item", NULL
34700 };
34701
34702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34704 if (SWIG_arg_fail(1)) SWIG_fail;
34705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34706 if (SWIG_arg_fail(2)) SWIG_fail;
34707 {
34708 PyThreadState* __tstate = wxPyBeginAllowThreads();
34709 result = (wxMenuItem *)(arg1)->Remove(arg2);
34710
34711 wxPyEndAllowThreads(__tstate);
34712 if (PyErr_Occurred()) SWIG_fail;
34713 }
34714 {
34715 resultobj = wxPyMake_wxObject(result, (bool)0);
34716 }
34717 return resultobj;
34718 fail:
34719 return NULL;
34720 }
34721
34722
34723 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34724 PyObject *resultobj = NULL;
34725 wxMenu *arg1 = (wxMenu *) 0 ;
34726 int arg2 ;
34727 bool result;
34728 PyObject * obj0 = 0 ;
34729 PyObject * obj1 = 0 ;
34730 char *kwnames[] = {
34731 (char *) "self",(char *) "id", NULL
34732 };
34733
34734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34736 if (SWIG_arg_fail(1)) SWIG_fail;
34737 {
34738 arg2 = static_cast<int >(SWIG_As_int(obj1));
34739 if (SWIG_arg_fail(2)) SWIG_fail;
34740 }
34741 {
34742 PyThreadState* __tstate = wxPyBeginAllowThreads();
34743 result = (bool)(arg1)->Delete(arg2);
34744
34745 wxPyEndAllowThreads(__tstate);
34746 if (PyErr_Occurred()) SWIG_fail;
34747 }
34748 {
34749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34750 }
34751 return resultobj;
34752 fail:
34753 return NULL;
34754 }
34755
34756
34757 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34758 PyObject *resultobj = NULL;
34759 wxMenu *arg1 = (wxMenu *) 0 ;
34760 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34761 bool result;
34762 PyObject * obj0 = 0 ;
34763 PyObject * obj1 = 0 ;
34764 char *kwnames[] = {
34765 (char *) "self",(char *) "item", NULL
34766 };
34767
34768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34770 if (SWIG_arg_fail(1)) SWIG_fail;
34771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34772 if (SWIG_arg_fail(2)) SWIG_fail;
34773 {
34774 PyThreadState* __tstate = wxPyBeginAllowThreads();
34775 result = (bool)(arg1)->Delete(arg2);
34776
34777 wxPyEndAllowThreads(__tstate);
34778 if (PyErr_Occurred()) SWIG_fail;
34779 }
34780 {
34781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34782 }
34783 return resultobj;
34784 fail:
34785 return NULL;
34786 }
34787
34788
34789 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34790 PyObject *resultobj = NULL;
34791 wxMenu *arg1 = (wxMenu *) 0 ;
34792 PyObject * obj0 = 0 ;
34793 char *kwnames[] = {
34794 (char *) "self", NULL
34795 };
34796
34797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34799 if (SWIG_arg_fail(1)) SWIG_fail;
34800 {
34801 PyThreadState* __tstate = wxPyBeginAllowThreads();
34802 wxMenu_Destroy(arg1);
34803
34804 wxPyEndAllowThreads(__tstate);
34805 if (PyErr_Occurred()) SWIG_fail;
34806 }
34807 Py_INCREF(Py_None); resultobj = Py_None;
34808 return resultobj;
34809 fail:
34810 return NULL;
34811 }
34812
34813
34814 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34815 PyObject *resultobj = NULL;
34816 wxMenu *arg1 = (wxMenu *) 0 ;
34817 int arg2 ;
34818 bool result;
34819 PyObject * obj0 = 0 ;
34820 PyObject * obj1 = 0 ;
34821 char *kwnames[] = {
34822 (char *) "self",(char *) "id", NULL
34823 };
34824
34825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34827 if (SWIG_arg_fail(1)) SWIG_fail;
34828 {
34829 arg2 = static_cast<int >(SWIG_As_int(obj1));
34830 if (SWIG_arg_fail(2)) SWIG_fail;
34831 }
34832 {
34833 PyThreadState* __tstate = wxPyBeginAllowThreads();
34834 result = (bool)(arg1)->Destroy(arg2);
34835
34836 wxPyEndAllowThreads(__tstate);
34837 if (PyErr_Occurred()) SWIG_fail;
34838 }
34839 {
34840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34841 }
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34849 PyObject *resultobj = NULL;
34850 wxMenu *arg1 = (wxMenu *) 0 ;
34851 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34852 bool result;
34853 PyObject * obj0 = 0 ;
34854 PyObject * obj1 = 0 ;
34855 char *kwnames[] = {
34856 (char *) "self",(char *) "item", NULL
34857 };
34858
34859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34861 if (SWIG_arg_fail(1)) SWIG_fail;
34862 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34863 if (SWIG_arg_fail(2)) SWIG_fail;
34864 {
34865 PyThreadState* __tstate = wxPyBeginAllowThreads();
34866 result = (bool)(arg1)->Destroy(arg2);
34867
34868 wxPyEndAllowThreads(__tstate);
34869 if (PyErr_Occurred()) SWIG_fail;
34870 }
34871 {
34872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34873 }
34874 return resultobj;
34875 fail:
34876 return NULL;
34877 }
34878
34879
34880 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34881 PyObject *resultobj = NULL;
34882 wxMenu *arg1 = (wxMenu *) 0 ;
34883 size_t result;
34884 PyObject * obj0 = 0 ;
34885 char *kwnames[] = {
34886 (char *) "self", NULL
34887 };
34888
34889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34891 if (SWIG_arg_fail(1)) SWIG_fail;
34892 {
34893 PyThreadState* __tstate = wxPyBeginAllowThreads();
34894 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34895
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 {
34900 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34901 }
34902 return resultobj;
34903 fail:
34904 return NULL;
34905 }
34906
34907
34908 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34909 PyObject *resultobj = NULL;
34910 wxMenu *arg1 = (wxMenu *) 0 ;
34911 PyObject *result;
34912 PyObject * obj0 = 0 ;
34913 char *kwnames[] = {
34914 (char *) "self", NULL
34915 };
34916
34917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34919 if (SWIG_arg_fail(1)) SWIG_fail;
34920 {
34921 PyThreadState* __tstate = wxPyBeginAllowThreads();
34922 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34923
34924 wxPyEndAllowThreads(__tstate);
34925 if (PyErr_Occurred()) SWIG_fail;
34926 }
34927 resultobj = result;
34928 return resultobj;
34929 fail:
34930 return NULL;
34931 }
34932
34933
34934 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34935 PyObject *resultobj = NULL;
34936 wxMenu *arg1 = (wxMenu *) 0 ;
34937 wxString *arg2 = 0 ;
34938 int result;
34939 bool temp2 = false ;
34940 PyObject * obj0 = 0 ;
34941 PyObject * obj1 = 0 ;
34942 char *kwnames[] = {
34943 (char *) "self",(char *) "item", NULL
34944 };
34945
34946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34948 if (SWIG_arg_fail(1)) SWIG_fail;
34949 {
34950 arg2 = wxString_in_helper(obj1);
34951 if (arg2 == NULL) SWIG_fail;
34952 temp2 = true;
34953 }
34954 {
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34957
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 {
34962 resultobj = SWIG_From_int(static_cast<int >(result));
34963 }
34964 {
34965 if (temp2)
34966 delete arg2;
34967 }
34968 return resultobj;
34969 fail:
34970 {
34971 if (temp2)
34972 delete arg2;
34973 }
34974 return NULL;
34975 }
34976
34977
34978 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34979 PyObject *resultobj = NULL;
34980 wxMenu *arg1 = (wxMenu *) 0 ;
34981 int arg2 ;
34982 wxMenuItem *result;
34983 PyObject * obj0 = 0 ;
34984 PyObject * obj1 = 0 ;
34985 char *kwnames[] = {
34986 (char *) "self",(char *) "id", NULL
34987 };
34988
34989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34991 if (SWIG_arg_fail(1)) SWIG_fail;
34992 {
34993 arg2 = static_cast<int >(SWIG_As_int(obj1));
34994 if (SWIG_arg_fail(2)) SWIG_fail;
34995 }
34996 {
34997 PyThreadState* __tstate = wxPyBeginAllowThreads();
34998 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34999
35000 wxPyEndAllowThreads(__tstate);
35001 if (PyErr_Occurred()) SWIG_fail;
35002 }
35003 {
35004 resultobj = wxPyMake_wxObject(result, (bool)0);
35005 }
35006 return resultobj;
35007 fail:
35008 return NULL;
35009 }
35010
35011
35012 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
35013 PyObject *resultobj = NULL;
35014 wxMenu *arg1 = (wxMenu *) 0 ;
35015 size_t arg2 ;
35016 wxMenuItem *result;
35017 PyObject * obj0 = 0 ;
35018 PyObject * obj1 = 0 ;
35019 char *kwnames[] = {
35020 (char *) "self",(char *) "position", NULL
35021 };
35022
35023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
35024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35025 if (SWIG_arg_fail(1)) SWIG_fail;
35026 {
35027 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35028 if (SWIG_arg_fail(2)) SWIG_fail;
35029 }
35030 {
35031 PyThreadState* __tstate = wxPyBeginAllowThreads();
35032 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
35033
35034 wxPyEndAllowThreads(__tstate);
35035 if (PyErr_Occurred()) SWIG_fail;
35036 }
35037 {
35038 resultobj = wxPyMake_wxObject(result, (bool)0);
35039 }
35040 return resultobj;
35041 fail:
35042 return NULL;
35043 }
35044
35045
35046 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35047 PyObject *resultobj = NULL;
35048 wxMenu *arg1 = (wxMenu *) 0 ;
35049 int arg2 ;
35050 bool arg3 ;
35051 PyObject * obj0 = 0 ;
35052 PyObject * obj1 = 0 ;
35053 PyObject * obj2 = 0 ;
35054 char *kwnames[] = {
35055 (char *) "self",(char *) "id",(char *) "enable", NULL
35056 };
35057
35058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35060 if (SWIG_arg_fail(1)) SWIG_fail;
35061 {
35062 arg2 = static_cast<int >(SWIG_As_int(obj1));
35063 if (SWIG_arg_fail(2)) SWIG_fail;
35064 }
35065 {
35066 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35067 if (SWIG_arg_fail(3)) SWIG_fail;
35068 }
35069 {
35070 PyThreadState* __tstate = wxPyBeginAllowThreads();
35071 (arg1)->Enable(arg2,arg3);
35072
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 Py_INCREF(Py_None); resultobj = Py_None;
35077 return resultobj;
35078 fail:
35079 return NULL;
35080 }
35081
35082
35083 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35084 PyObject *resultobj = NULL;
35085 wxMenu *arg1 = (wxMenu *) 0 ;
35086 int arg2 ;
35087 bool result;
35088 PyObject * obj0 = 0 ;
35089 PyObject * obj1 = 0 ;
35090 char *kwnames[] = {
35091 (char *) "self",(char *) "id", NULL
35092 };
35093
35094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35096 if (SWIG_arg_fail(1)) SWIG_fail;
35097 {
35098 arg2 = static_cast<int >(SWIG_As_int(obj1));
35099 if (SWIG_arg_fail(2)) SWIG_fail;
35100 }
35101 {
35102 PyThreadState* __tstate = wxPyBeginAllowThreads();
35103 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35104
35105 wxPyEndAllowThreads(__tstate);
35106 if (PyErr_Occurred()) SWIG_fail;
35107 }
35108 {
35109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35110 }
35111 return resultobj;
35112 fail:
35113 return NULL;
35114 }
35115
35116
35117 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35118 PyObject *resultobj = NULL;
35119 wxMenu *arg1 = (wxMenu *) 0 ;
35120 int arg2 ;
35121 bool arg3 ;
35122 PyObject * obj0 = 0 ;
35123 PyObject * obj1 = 0 ;
35124 PyObject * obj2 = 0 ;
35125 char *kwnames[] = {
35126 (char *) "self",(char *) "id",(char *) "check", NULL
35127 };
35128
35129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35131 if (SWIG_arg_fail(1)) SWIG_fail;
35132 {
35133 arg2 = static_cast<int >(SWIG_As_int(obj1));
35134 if (SWIG_arg_fail(2)) SWIG_fail;
35135 }
35136 {
35137 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35138 if (SWIG_arg_fail(3)) SWIG_fail;
35139 }
35140 {
35141 PyThreadState* __tstate = wxPyBeginAllowThreads();
35142 (arg1)->Check(arg2,arg3);
35143
35144 wxPyEndAllowThreads(__tstate);
35145 if (PyErr_Occurred()) SWIG_fail;
35146 }
35147 Py_INCREF(Py_None); resultobj = Py_None;
35148 return resultobj;
35149 fail:
35150 return NULL;
35151 }
35152
35153
35154 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35155 PyObject *resultobj = NULL;
35156 wxMenu *arg1 = (wxMenu *) 0 ;
35157 int arg2 ;
35158 bool result;
35159 PyObject * obj0 = 0 ;
35160 PyObject * obj1 = 0 ;
35161 char *kwnames[] = {
35162 (char *) "self",(char *) "id", NULL
35163 };
35164
35165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35167 if (SWIG_arg_fail(1)) SWIG_fail;
35168 {
35169 arg2 = static_cast<int >(SWIG_As_int(obj1));
35170 if (SWIG_arg_fail(2)) SWIG_fail;
35171 }
35172 {
35173 PyThreadState* __tstate = wxPyBeginAllowThreads();
35174 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35175
35176 wxPyEndAllowThreads(__tstate);
35177 if (PyErr_Occurred()) SWIG_fail;
35178 }
35179 {
35180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35181 }
35182 return resultobj;
35183 fail:
35184 return NULL;
35185 }
35186
35187
35188 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35189 PyObject *resultobj = NULL;
35190 wxMenu *arg1 = (wxMenu *) 0 ;
35191 int arg2 ;
35192 wxString *arg3 = 0 ;
35193 bool temp3 = false ;
35194 PyObject * obj0 = 0 ;
35195 PyObject * obj1 = 0 ;
35196 PyObject * obj2 = 0 ;
35197 char *kwnames[] = {
35198 (char *) "self",(char *) "id",(char *) "label", NULL
35199 };
35200
35201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35203 if (SWIG_arg_fail(1)) SWIG_fail;
35204 {
35205 arg2 = static_cast<int >(SWIG_As_int(obj1));
35206 if (SWIG_arg_fail(2)) SWIG_fail;
35207 }
35208 {
35209 arg3 = wxString_in_helper(obj2);
35210 if (arg3 == NULL) SWIG_fail;
35211 temp3 = true;
35212 }
35213 {
35214 PyThreadState* __tstate = wxPyBeginAllowThreads();
35215 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35216
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 Py_INCREF(Py_None); resultobj = Py_None;
35221 {
35222 if (temp3)
35223 delete arg3;
35224 }
35225 return resultobj;
35226 fail:
35227 {
35228 if (temp3)
35229 delete arg3;
35230 }
35231 return NULL;
35232 }
35233
35234
35235 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35236 PyObject *resultobj = NULL;
35237 wxMenu *arg1 = (wxMenu *) 0 ;
35238 int arg2 ;
35239 wxString result;
35240 PyObject * obj0 = 0 ;
35241 PyObject * obj1 = 0 ;
35242 char *kwnames[] = {
35243 (char *) "self",(char *) "id", NULL
35244 };
35245
35246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35248 if (SWIG_arg_fail(1)) SWIG_fail;
35249 {
35250 arg2 = static_cast<int >(SWIG_As_int(obj1));
35251 if (SWIG_arg_fail(2)) SWIG_fail;
35252 }
35253 {
35254 PyThreadState* __tstate = wxPyBeginAllowThreads();
35255 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35256
35257 wxPyEndAllowThreads(__tstate);
35258 if (PyErr_Occurred()) SWIG_fail;
35259 }
35260 {
35261 #if wxUSE_UNICODE
35262 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35263 #else
35264 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35265 #endif
35266 }
35267 return resultobj;
35268 fail:
35269 return NULL;
35270 }
35271
35272
35273 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35274 PyObject *resultobj = NULL;
35275 wxMenu *arg1 = (wxMenu *) 0 ;
35276 int arg2 ;
35277 wxString *arg3 = 0 ;
35278 bool temp3 = false ;
35279 PyObject * obj0 = 0 ;
35280 PyObject * obj1 = 0 ;
35281 PyObject * obj2 = 0 ;
35282 char *kwnames[] = {
35283 (char *) "self",(char *) "id",(char *) "helpString", NULL
35284 };
35285
35286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35288 if (SWIG_arg_fail(1)) SWIG_fail;
35289 {
35290 arg2 = static_cast<int >(SWIG_As_int(obj1));
35291 if (SWIG_arg_fail(2)) SWIG_fail;
35292 }
35293 {
35294 arg3 = wxString_in_helper(obj2);
35295 if (arg3 == NULL) SWIG_fail;
35296 temp3 = true;
35297 }
35298 {
35299 PyThreadState* __tstate = wxPyBeginAllowThreads();
35300 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35301
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 Py_INCREF(Py_None); resultobj = Py_None;
35306 {
35307 if (temp3)
35308 delete arg3;
35309 }
35310 return resultobj;
35311 fail:
35312 {
35313 if (temp3)
35314 delete arg3;
35315 }
35316 return NULL;
35317 }
35318
35319
35320 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35321 PyObject *resultobj = NULL;
35322 wxMenu *arg1 = (wxMenu *) 0 ;
35323 int arg2 ;
35324 wxString result;
35325 PyObject * obj0 = 0 ;
35326 PyObject * obj1 = 0 ;
35327 char *kwnames[] = {
35328 (char *) "self",(char *) "id", NULL
35329 };
35330
35331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35333 if (SWIG_arg_fail(1)) SWIG_fail;
35334 {
35335 arg2 = static_cast<int >(SWIG_As_int(obj1));
35336 if (SWIG_arg_fail(2)) SWIG_fail;
35337 }
35338 {
35339 PyThreadState* __tstate = wxPyBeginAllowThreads();
35340 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35341
35342 wxPyEndAllowThreads(__tstate);
35343 if (PyErr_Occurred()) SWIG_fail;
35344 }
35345 {
35346 #if wxUSE_UNICODE
35347 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35348 #else
35349 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35350 #endif
35351 }
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35359 PyObject *resultobj = NULL;
35360 wxMenu *arg1 = (wxMenu *) 0 ;
35361 wxString *arg2 = 0 ;
35362 bool temp2 = false ;
35363 PyObject * obj0 = 0 ;
35364 PyObject * obj1 = 0 ;
35365 char *kwnames[] = {
35366 (char *) "self",(char *) "title", NULL
35367 };
35368
35369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35371 if (SWIG_arg_fail(1)) SWIG_fail;
35372 {
35373 arg2 = wxString_in_helper(obj1);
35374 if (arg2 == NULL) SWIG_fail;
35375 temp2 = true;
35376 }
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 (arg1)->SetTitle((wxString const &)*arg2);
35380
35381 wxPyEndAllowThreads(__tstate);
35382 if (PyErr_Occurred()) SWIG_fail;
35383 }
35384 Py_INCREF(Py_None); resultobj = Py_None;
35385 {
35386 if (temp2)
35387 delete arg2;
35388 }
35389 return resultobj;
35390 fail:
35391 {
35392 if (temp2)
35393 delete arg2;
35394 }
35395 return NULL;
35396 }
35397
35398
35399 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35400 PyObject *resultobj = NULL;
35401 wxMenu *arg1 = (wxMenu *) 0 ;
35402 wxString result;
35403 PyObject * obj0 = 0 ;
35404 char *kwnames[] = {
35405 (char *) "self", NULL
35406 };
35407
35408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35410 if (SWIG_arg_fail(1)) SWIG_fail;
35411 {
35412 PyThreadState* __tstate = wxPyBeginAllowThreads();
35413 result = ((wxMenu const *)arg1)->GetTitle();
35414
35415 wxPyEndAllowThreads(__tstate);
35416 if (PyErr_Occurred()) SWIG_fail;
35417 }
35418 {
35419 #if wxUSE_UNICODE
35420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35421 #else
35422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35423 #endif
35424 }
35425 return resultobj;
35426 fail:
35427 return NULL;
35428 }
35429
35430
35431 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35432 PyObject *resultobj = NULL;
35433 wxMenu *arg1 = (wxMenu *) 0 ;
35434 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35435 PyObject * obj0 = 0 ;
35436 PyObject * obj1 = 0 ;
35437 char *kwnames[] = {
35438 (char *) "self",(char *) "handler", NULL
35439 };
35440
35441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35443 if (SWIG_arg_fail(1)) SWIG_fail;
35444 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35445 if (SWIG_arg_fail(2)) SWIG_fail;
35446 {
35447 PyThreadState* __tstate = wxPyBeginAllowThreads();
35448 (arg1)->SetEventHandler(arg2);
35449
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 Py_INCREF(Py_None); resultobj = Py_None;
35454 return resultobj;
35455 fail:
35456 return NULL;
35457 }
35458
35459
35460 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35461 PyObject *resultobj = NULL;
35462 wxMenu *arg1 = (wxMenu *) 0 ;
35463 wxEvtHandler *result;
35464 PyObject * obj0 = 0 ;
35465 char *kwnames[] = {
35466 (char *) "self", NULL
35467 };
35468
35469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",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 = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35475
35476 wxPyEndAllowThreads(__tstate);
35477 if (PyErr_Occurred()) SWIG_fail;
35478 }
35479 {
35480 resultobj = wxPyMake_wxObject(result, 0);
35481 }
35482 return resultobj;
35483 fail:
35484 return NULL;
35485 }
35486
35487
35488 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35489 PyObject *resultobj = NULL;
35490 wxMenu *arg1 = (wxMenu *) 0 ;
35491 wxWindow *arg2 = (wxWindow *) 0 ;
35492 PyObject * obj0 = 0 ;
35493 PyObject * obj1 = 0 ;
35494 char *kwnames[] = {
35495 (char *) "self",(char *) "win", NULL
35496 };
35497
35498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35500 if (SWIG_arg_fail(1)) SWIG_fail;
35501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35502 if (SWIG_arg_fail(2)) SWIG_fail;
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 (arg1)->SetInvokingWindow(arg2);
35506
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 Py_INCREF(Py_None); resultobj = Py_None;
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj = NULL;
35519 wxMenu *arg1 = (wxMenu *) 0 ;
35520 wxWindow *result;
35521 PyObject * obj0 = 0 ;
35522 char *kwnames[] = {
35523 (char *) "self", NULL
35524 };
35525
35526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35528 if (SWIG_arg_fail(1)) SWIG_fail;
35529 {
35530 PyThreadState* __tstate = wxPyBeginAllowThreads();
35531 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35532
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 {
35537 resultobj = wxPyMake_wxObject(result, 0);
35538 }
35539 return resultobj;
35540 fail:
35541 return NULL;
35542 }
35543
35544
35545 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35546 PyObject *resultobj = NULL;
35547 wxMenu *arg1 = (wxMenu *) 0 ;
35548 long result;
35549 PyObject * obj0 = 0 ;
35550 char *kwnames[] = {
35551 (char *) "self", NULL
35552 };
35553
35554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35556 if (SWIG_arg_fail(1)) SWIG_fail;
35557 {
35558 PyThreadState* __tstate = wxPyBeginAllowThreads();
35559 result = (long)((wxMenu const *)arg1)->GetStyle();
35560
35561 wxPyEndAllowThreads(__tstate);
35562 if (PyErr_Occurred()) SWIG_fail;
35563 }
35564 {
35565 resultobj = SWIG_From_long(static_cast<long >(result));
35566 }
35567 return resultobj;
35568 fail:
35569 return NULL;
35570 }
35571
35572
35573 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35574 PyObject *resultobj = NULL;
35575 wxMenu *arg1 = (wxMenu *) 0 ;
35576 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35577 PyObject * obj0 = 0 ;
35578 PyObject * obj1 = 0 ;
35579 char *kwnames[] = {
35580 (char *) "self",(char *) "source", NULL
35581 };
35582
35583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35585 if (SWIG_arg_fail(1)) SWIG_fail;
35586 if (obj1) {
35587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35588 if (SWIG_arg_fail(2)) SWIG_fail;
35589 }
35590 {
35591 PyThreadState* __tstate = wxPyBeginAllowThreads();
35592 (arg1)->UpdateUI(arg2);
35593
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 Py_INCREF(Py_None); resultobj = Py_None;
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35605 PyObject *resultobj = NULL;
35606 wxMenu *arg1 = (wxMenu *) 0 ;
35607 wxMenuBar *result;
35608 PyObject * obj0 = 0 ;
35609 char *kwnames[] = {
35610 (char *) "self", NULL
35611 };
35612
35613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35615 if (SWIG_arg_fail(1)) SWIG_fail;
35616 {
35617 PyThreadState* __tstate = wxPyBeginAllowThreads();
35618 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35619
35620 wxPyEndAllowThreads(__tstate);
35621 if (PyErr_Occurred()) SWIG_fail;
35622 }
35623 {
35624 resultobj = wxPyMake_wxObject(result, (bool)0);
35625 }
35626 return resultobj;
35627 fail:
35628 return NULL;
35629 }
35630
35631
35632 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35633 PyObject *resultobj = NULL;
35634 wxMenu *arg1 = (wxMenu *) 0 ;
35635 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35636 PyObject * obj0 = 0 ;
35637 PyObject * obj1 = 0 ;
35638 char *kwnames[] = {
35639 (char *) "self",(char *) "menubar", NULL
35640 };
35641
35642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35644 if (SWIG_arg_fail(1)) SWIG_fail;
35645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35646 if (SWIG_arg_fail(2)) SWIG_fail;
35647 {
35648 PyThreadState* __tstate = wxPyBeginAllowThreads();
35649 (arg1)->Attach(arg2);
35650
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 Py_INCREF(Py_None); resultobj = Py_None;
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35662 PyObject *resultobj = NULL;
35663 wxMenu *arg1 = (wxMenu *) 0 ;
35664 PyObject * obj0 = 0 ;
35665 char *kwnames[] = {
35666 (char *) "self", NULL
35667 };
35668
35669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35671 if (SWIG_arg_fail(1)) SWIG_fail;
35672 {
35673 PyThreadState* __tstate = wxPyBeginAllowThreads();
35674 (arg1)->Detach();
35675
35676 wxPyEndAllowThreads(__tstate);
35677 if (PyErr_Occurred()) SWIG_fail;
35678 }
35679 Py_INCREF(Py_None); resultobj = Py_None;
35680 return resultobj;
35681 fail:
35682 return NULL;
35683 }
35684
35685
35686 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35687 PyObject *resultobj = NULL;
35688 wxMenu *arg1 = (wxMenu *) 0 ;
35689 bool result;
35690 PyObject * obj0 = 0 ;
35691 char *kwnames[] = {
35692 (char *) "self", NULL
35693 };
35694
35695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35697 if (SWIG_arg_fail(1)) SWIG_fail;
35698 {
35699 PyThreadState* __tstate = wxPyBeginAllowThreads();
35700 result = (bool)((wxMenu const *)arg1)->IsAttached();
35701
35702 wxPyEndAllowThreads(__tstate);
35703 if (PyErr_Occurred()) SWIG_fail;
35704 }
35705 {
35706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35707 }
35708 return resultobj;
35709 fail:
35710 return NULL;
35711 }
35712
35713
35714 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35715 PyObject *resultobj = NULL;
35716 wxMenu *arg1 = (wxMenu *) 0 ;
35717 wxMenu *arg2 = (wxMenu *) 0 ;
35718 PyObject * obj0 = 0 ;
35719 PyObject * obj1 = 0 ;
35720 char *kwnames[] = {
35721 (char *) "self",(char *) "parent", NULL
35722 };
35723
35724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35726 if (SWIG_arg_fail(1)) SWIG_fail;
35727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35728 if (SWIG_arg_fail(2)) SWIG_fail;
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 (arg1)->SetParent(arg2);
35732
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 Py_INCREF(Py_None); resultobj = Py_None;
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35744 PyObject *resultobj = NULL;
35745 wxMenu *arg1 = (wxMenu *) 0 ;
35746 wxMenu *result;
35747 PyObject * obj0 = 0 ;
35748 char *kwnames[] = {
35749 (char *) "self", NULL
35750 };
35751
35752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35754 if (SWIG_arg_fail(1)) SWIG_fail;
35755 {
35756 PyThreadState* __tstate = wxPyBeginAllowThreads();
35757 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35758
35759 wxPyEndAllowThreads(__tstate);
35760 if (PyErr_Occurred()) SWIG_fail;
35761 }
35762 {
35763 resultobj = wxPyMake_wxObject(result, 0);
35764 }
35765 return resultobj;
35766 fail:
35767 return NULL;
35768 }
35769
35770
35771 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35772 PyObject *obj;
35773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35774 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35775 Py_INCREF(obj);
35776 return Py_BuildValue((char *)"");
35777 }
35778 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35779 PyObject *resultobj = NULL;
35780 long arg1 = (long) 0 ;
35781 wxMenuBar *result;
35782 PyObject * obj0 = 0 ;
35783 char *kwnames[] = {
35784 (char *) "style", NULL
35785 };
35786
35787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35788 if (obj0) {
35789 {
35790 arg1 = static_cast<long >(SWIG_As_long(obj0));
35791 if (SWIG_arg_fail(1)) SWIG_fail;
35792 }
35793 }
35794 {
35795 if (!wxPyCheckForApp()) SWIG_fail;
35796 PyThreadState* __tstate = wxPyBeginAllowThreads();
35797 result = (wxMenuBar *)new wxMenuBar(arg1);
35798
35799 wxPyEndAllowThreads(__tstate);
35800 if (PyErr_Occurred()) SWIG_fail;
35801 }
35802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35803 return resultobj;
35804 fail:
35805 return NULL;
35806 }
35807
35808
35809 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35810 PyObject *resultobj = NULL;
35811 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35812 wxMenu *arg2 = (wxMenu *) 0 ;
35813 wxString *arg3 = 0 ;
35814 bool result;
35815 bool temp3 = false ;
35816 PyObject * obj0 = 0 ;
35817 PyObject * obj1 = 0 ;
35818 PyObject * obj2 = 0 ;
35819 char *kwnames[] = {
35820 (char *) "self",(char *) "menu",(char *) "title", NULL
35821 };
35822
35823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35825 if (SWIG_arg_fail(1)) SWIG_fail;
35826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35827 if (SWIG_arg_fail(2)) SWIG_fail;
35828 {
35829 arg3 = wxString_in_helper(obj2);
35830 if (arg3 == NULL) SWIG_fail;
35831 temp3 = true;
35832 }
35833 {
35834 PyThreadState* __tstate = wxPyBeginAllowThreads();
35835 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35836
35837 wxPyEndAllowThreads(__tstate);
35838 if (PyErr_Occurred()) SWIG_fail;
35839 }
35840 {
35841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35842 }
35843 {
35844 if (temp3)
35845 delete arg3;
35846 }
35847 return resultobj;
35848 fail:
35849 {
35850 if (temp3)
35851 delete arg3;
35852 }
35853 return NULL;
35854 }
35855
35856
35857 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35858 PyObject *resultobj = NULL;
35859 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35860 size_t arg2 ;
35861 wxMenu *arg3 = (wxMenu *) 0 ;
35862 wxString *arg4 = 0 ;
35863 bool result;
35864 bool temp4 = false ;
35865 PyObject * obj0 = 0 ;
35866 PyObject * obj1 = 0 ;
35867 PyObject * obj2 = 0 ;
35868 PyObject * obj3 = 0 ;
35869 char *kwnames[] = {
35870 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35871 };
35872
35873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35875 if (SWIG_arg_fail(1)) SWIG_fail;
35876 {
35877 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35878 if (SWIG_arg_fail(2)) SWIG_fail;
35879 }
35880 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35881 if (SWIG_arg_fail(3)) SWIG_fail;
35882 {
35883 arg4 = wxString_in_helper(obj3);
35884 if (arg4 == NULL) SWIG_fail;
35885 temp4 = true;
35886 }
35887 {
35888 PyThreadState* __tstate = wxPyBeginAllowThreads();
35889 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35890
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 {
35895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35896 }
35897 {
35898 if (temp4)
35899 delete arg4;
35900 }
35901 return resultobj;
35902 fail:
35903 {
35904 if (temp4)
35905 delete arg4;
35906 }
35907 return NULL;
35908 }
35909
35910
35911 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35912 PyObject *resultobj = NULL;
35913 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35914 size_t result;
35915 PyObject * obj0 = 0 ;
35916 char *kwnames[] = {
35917 (char *) "self", NULL
35918 };
35919
35920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35922 if (SWIG_arg_fail(1)) SWIG_fail;
35923 {
35924 PyThreadState* __tstate = wxPyBeginAllowThreads();
35925 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35926
35927 wxPyEndAllowThreads(__tstate);
35928 if (PyErr_Occurred()) SWIG_fail;
35929 }
35930 {
35931 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35932 }
35933 return resultobj;
35934 fail:
35935 return NULL;
35936 }
35937
35938
35939 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35940 PyObject *resultobj = NULL;
35941 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35942 size_t arg2 ;
35943 wxMenu *result;
35944 PyObject * obj0 = 0 ;
35945 PyObject * obj1 = 0 ;
35946 char *kwnames[] = {
35947 (char *) "self",(char *) "pos", NULL
35948 };
35949
35950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35952 if (SWIG_arg_fail(1)) SWIG_fail;
35953 {
35954 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35955 if (SWIG_arg_fail(2)) SWIG_fail;
35956 }
35957 {
35958 PyThreadState* __tstate = wxPyBeginAllowThreads();
35959 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35960
35961 wxPyEndAllowThreads(__tstate);
35962 if (PyErr_Occurred()) SWIG_fail;
35963 }
35964 {
35965 resultobj = wxPyMake_wxObject(result, 0);
35966 }
35967 return resultobj;
35968 fail:
35969 return NULL;
35970 }
35971
35972
35973 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35974 PyObject *resultobj = NULL;
35975 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35976 size_t arg2 ;
35977 wxMenu *arg3 = (wxMenu *) 0 ;
35978 wxString *arg4 = 0 ;
35979 wxMenu *result;
35980 bool temp4 = false ;
35981 PyObject * obj0 = 0 ;
35982 PyObject * obj1 = 0 ;
35983 PyObject * obj2 = 0 ;
35984 PyObject * obj3 = 0 ;
35985 char *kwnames[] = {
35986 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35987 };
35988
35989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35991 if (SWIG_arg_fail(1)) SWIG_fail;
35992 {
35993 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35994 if (SWIG_arg_fail(2)) SWIG_fail;
35995 }
35996 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35997 if (SWIG_arg_fail(3)) SWIG_fail;
35998 {
35999 arg4 = wxString_in_helper(obj3);
36000 if (arg4 == NULL) SWIG_fail;
36001 temp4 = true;
36002 }
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
36006
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 {
36011 resultobj = wxPyMake_wxObject(result, 0);
36012 }
36013 {
36014 if (temp4)
36015 delete arg4;
36016 }
36017 return resultobj;
36018 fail:
36019 {
36020 if (temp4)
36021 delete arg4;
36022 }
36023 return NULL;
36024 }
36025
36026
36027 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
36028 PyObject *resultobj = NULL;
36029 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36030 size_t arg2 ;
36031 wxMenu *result;
36032 PyObject * obj0 = 0 ;
36033 PyObject * obj1 = 0 ;
36034 char *kwnames[] = {
36035 (char *) "self",(char *) "pos", NULL
36036 };
36037
36038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
36039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36040 if (SWIG_arg_fail(1)) SWIG_fail;
36041 {
36042 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36043 if (SWIG_arg_fail(2)) SWIG_fail;
36044 }
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 result = (wxMenu *)(arg1)->Remove(arg2);
36048
36049 wxPyEndAllowThreads(__tstate);
36050 if (PyErr_Occurred()) SWIG_fail;
36051 }
36052 {
36053 resultobj = wxPyMake_wxObject(result, 0);
36054 }
36055 return resultobj;
36056 fail:
36057 return NULL;
36058 }
36059
36060
36061 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
36062 PyObject *resultobj = NULL;
36063 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36064 size_t arg2 ;
36065 bool arg3 ;
36066 PyObject * obj0 = 0 ;
36067 PyObject * obj1 = 0 ;
36068 PyObject * obj2 = 0 ;
36069 char *kwnames[] = {
36070 (char *) "self",(char *) "pos",(char *) "enable", NULL
36071 };
36072
36073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36075 if (SWIG_arg_fail(1)) SWIG_fail;
36076 {
36077 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36078 if (SWIG_arg_fail(2)) SWIG_fail;
36079 }
36080 {
36081 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36082 if (SWIG_arg_fail(3)) SWIG_fail;
36083 }
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 (arg1)->EnableTop(arg2,arg3);
36087
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 Py_INCREF(Py_None); resultobj = Py_None;
36092 return resultobj;
36093 fail:
36094 return NULL;
36095 }
36096
36097
36098 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36099 PyObject *resultobj = NULL;
36100 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36101 size_t arg2 ;
36102 bool result;
36103 PyObject * obj0 = 0 ;
36104 PyObject * obj1 = 0 ;
36105 char *kwnames[] = {
36106 (char *) "self",(char *) "pos", NULL
36107 };
36108
36109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36111 if (SWIG_arg_fail(1)) SWIG_fail;
36112 {
36113 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36114 if (SWIG_arg_fail(2)) SWIG_fail;
36115 }
36116 {
36117 PyThreadState* __tstate = wxPyBeginAllowThreads();
36118 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36119
36120 wxPyEndAllowThreads(__tstate);
36121 if (PyErr_Occurred()) SWIG_fail;
36122 }
36123 {
36124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36125 }
36126 return resultobj;
36127 fail:
36128 return NULL;
36129 }
36130
36131
36132 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36133 PyObject *resultobj = NULL;
36134 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36135 size_t arg2 ;
36136 wxString *arg3 = 0 ;
36137 bool temp3 = false ;
36138 PyObject * obj0 = 0 ;
36139 PyObject * obj1 = 0 ;
36140 PyObject * obj2 = 0 ;
36141 char *kwnames[] = {
36142 (char *) "self",(char *) "pos",(char *) "label", NULL
36143 };
36144
36145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36147 if (SWIG_arg_fail(1)) SWIG_fail;
36148 {
36149 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36150 if (SWIG_arg_fail(2)) SWIG_fail;
36151 }
36152 {
36153 arg3 = wxString_in_helper(obj2);
36154 if (arg3 == NULL) SWIG_fail;
36155 temp3 = true;
36156 }
36157 {
36158 PyThreadState* __tstate = wxPyBeginAllowThreads();
36159 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36160
36161 wxPyEndAllowThreads(__tstate);
36162 if (PyErr_Occurred()) SWIG_fail;
36163 }
36164 Py_INCREF(Py_None); resultobj = Py_None;
36165 {
36166 if (temp3)
36167 delete arg3;
36168 }
36169 return resultobj;
36170 fail:
36171 {
36172 if (temp3)
36173 delete arg3;
36174 }
36175 return NULL;
36176 }
36177
36178
36179 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36180 PyObject *resultobj = NULL;
36181 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36182 size_t arg2 ;
36183 wxString result;
36184 PyObject * obj0 = 0 ;
36185 PyObject * obj1 = 0 ;
36186 char *kwnames[] = {
36187 (char *) "self",(char *) "pos", NULL
36188 };
36189
36190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36192 if (SWIG_arg_fail(1)) SWIG_fail;
36193 {
36194 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36195 if (SWIG_arg_fail(2)) SWIG_fail;
36196 }
36197 {
36198 PyThreadState* __tstate = wxPyBeginAllowThreads();
36199 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36200
36201 wxPyEndAllowThreads(__tstate);
36202 if (PyErr_Occurred()) SWIG_fail;
36203 }
36204 {
36205 #if wxUSE_UNICODE
36206 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36207 #else
36208 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36209 #endif
36210 }
36211 return resultobj;
36212 fail:
36213 return NULL;
36214 }
36215
36216
36217 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36218 PyObject *resultobj = NULL;
36219 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36220 wxString *arg2 = 0 ;
36221 wxString *arg3 = 0 ;
36222 int result;
36223 bool temp2 = false ;
36224 bool temp3 = false ;
36225 PyObject * obj0 = 0 ;
36226 PyObject * obj1 = 0 ;
36227 PyObject * obj2 = 0 ;
36228 char *kwnames[] = {
36229 (char *) "self",(char *) "menu",(char *) "item", NULL
36230 };
36231
36232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36234 if (SWIG_arg_fail(1)) SWIG_fail;
36235 {
36236 arg2 = wxString_in_helper(obj1);
36237 if (arg2 == NULL) SWIG_fail;
36238 temp2 = true;
36239 }
36240 {
36241 arg3 = wxString_in_helper(obj2);
36242 if (arg3 == NULL) SWIG_fail;
36243 temp3 = true;
36244 }
36245 {
36246 PyThreadState* __tstate = wxPyBeginAllowThreads();
36247 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36248
36249 wxPyEndAllowThreads(__tstate);
36250 if (PyErr_Occurred()) SWIG_fail;
36251 }
36252 {
36253 resultobj = SWIG_From_int(static_cast<int >(result));
36254 }
36255 {
36256 if (temp2)
36257 delete arg2;
36258 }
36259 {
36260 if (temp3)
36261 delete arg3;
36262 }
36263 return resultobj;
36264 fail:
36265 {
36266 if (temp2)
36267 delete arg2;
36268 }
36269 {
36270 if (temp3)
36271 delete arg3;
36272 }
36273 return NULL;
36274 }
36275
36276
36277 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36278 PyObject *resultobj = NULL;
36279 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36280 int arg2 ;
36281 wxMenuItem *result;
36282 PyObject * obj0 = 0 ;
36283 PyObject * obj1 = 0 ;
36284 char *kwnames[] = {
36285 (char *) "self",(char *) "id", NULL
36286 };
36287
36288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36290 if (SWIG_arg_fail(1)) SWIG_fail;
36291 {
36292 arg2 = static_cast<int >(SWIG_As_int(obj1));
36293 if (SWIG_arg_fail(2)) SWIG_fail;
36294 }
36295 {
36296 PyThreadState* __tstate = wxPyBeginAllowThreads();
36297 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36298
36299 wxPyEndAllowThreads(__tstate);
36300 if (PyErr_Occurred()) SWIG_fail;
36301 }
36302 {
36303 resultobj = wxPyMake_wxObject(result, (bool)0);
36304 }
36305 return resultobj;
36306 fail:
36307 return NULL;
36308 }
36309
36310
36311 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36312 PyObject *resultobj = NULL;
36313 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36314 wxString *arg2 = 0 ;
36315 int result;
36316 bool temp2 = false ;
36317 PyObject * obj0 = 0 ;
36318 PyObject * obj1 = 0 ;
36319 char *kwnames[] = {
36320 (char *) "self",(char *) "title", NULL
36321 };
36322
36323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36325 if (SWIG_arg_fail(1)) SWIG_fail;
36326 {
36327 arg2 = wxString_in_helper(obj1);
36328 if (arg2 == NULL) SWIG_fail;
36329 temp2 = true;
36330 }
36331 {
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36334
36335 wxPyEndAllowThreads(__tstate);
36336 if (PyErr_Occurred()) SWIG_fail;
36337 }
36338 {
36339 resultobj = SWIG_From_int(static_cast<int >(result));
36340 }
36341 {
36342 if (temp2)
36343 delete arg2;
36344 }
36345 return resultobj;
36346 fail:
36347 {
36348 if (temp2)
36349 delete arg2;
36350 }
36351 return NULL;
36352 }
36353
36354
36355 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36356 PyObject *resultobj = NULL;
36357 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36358 int arg2 ;
36359 bool arg3 ;
36360 PyObject * obj0 = 0 ;
36361 PyObject * obj1 = 0 ;
36362 PyObject * obj2 = 0 ;
36363 char *kwnames[] = {
36364 (char *) "self",(char *) "id",(char *) "enable", NULL
36365 };
36366
36367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36369 if (SWIG_arg_fail(1)) SWIG_fail;
36370 {
36371 arg2 = static_cast<int >(SWIG_As_int(obj1));
36372 if (SWIG_arg_fail(2)) SWIG_fail;
36373 }
36374 {
36375 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36376 if (SWIG_arg_fail(3)) SWIG_fail;
36377 }
36378 {
36379 PyThreadState* __tstate = wxPyBeginAllowThreads();
36380 (arg1)->Enable(arg2,arg3);
36381
36382 wxPyEndAllowThreads(__tstate);
36383 if (PyErr_Occurred()) SWIG_fail;
36384 }
36385 Py_INCREF(Py_None); resultobj = Py_None;
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36393 PyObject *resultobj = NULL;
36394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36395 int arg2 ;
36396 bool arg3 ;
36397 PyObject * obj0 = 0 ;
36398 PyObject * obj1 = 0 ;
36399 PyObject * obj2 = 0 ;
36400 char *kwnames[] = {
36401 (char *) "self",(char *) "id",(char *) "check", NULL
36402 };
36403
36404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36406 if (SWIG_arg_fail(1)) SWIG_fail;
36407 {
36408 arg2 = static_cast<int >(SWIG_As_int(obj1));
36409 if (SWIG_arg_fail(2)) SWIG_fail;
36410 }
36411 {
36412 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36413 if (SWIG_arg_fail(3)) SWIG_fail;
36414 }
36415 {
36416 PyThreadState* __tstate = wxPyBeginAllowThreads();
36417 (arg1)->Check(arg2,arg3);
36418
36419 wxPyEndAllowThreads(__tstate);
36420 if (PyErr_Occurred()) SWIG_fail;
36421 }
36422 Py_INCREF(Py_None); resultobj = Py_None;
36423 return resultobj;
36424 fail:
36425 return NULL;
36426 }
36427
36428
36429 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36430 PyObject *resultobj = NULL;
36431 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36432 int arg2 ;
36433 bool result;
36434 PyObject * obj0 = 0 ;
36435 PyObject * obj1 = 0 ;
36436 char *kwnames[] = {
36437 (char *) "self",(char *) "id", NULL
36438 };
36439
36440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36442 if (SWIG_arg_fail(1)) SWIG_fail;
36443 {
36444 arg2 = static_cast<int >(SWIG_As_int(obj1));
36445 if (SWIG_arg_fail(2)) SWIG_fail;
36446 }
36447 {
36448 PyThreadState* __tstate = wxPyBeginAllowThreads();
36449 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36450
36451 wxPyEndAllowThreads(__tstate);
36452 if (PyErr_Occurred()) SWIG_fail;
36453 }
36454 {
36455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36456 }
36457 return resultobj;
36458 fail:
36459 return NULL;
36460 }
36461
36462
36463 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36464 PyObject *resultobj = NULL;
36465 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36466 int arg2 ;
36467 bool result;
36468 PyObject * obj0 = 0 ;
36469 PyObject * obj1 = 0 ;
36470 char *kwnames[] = {
36471 (char *) "self",(char *) "id", NULL
36472 };
36473
36474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36476 if (SWIG_arg_fail(1)) SWIG_fail;
36477 {
36478 arg2 = static_cast<int >(SWIG_As_int(obj1));
36479 if (SWIG_arg_fail(2)) SWIG_fail;
36480 }
36481 {
36482 PyThreadState* __tstate = wxPyBeginAllowThreads();
36483 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36484
36485 wxPyEndAllowThreads(__tstate);
36486 if (PyErr_Occurred()) SWIG_fail;
36487 }
36488 {
36489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36490 }
36491 return resultobj;
36492 fail:
36493 return NULL;
36494 }
36495
36496
36497 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36498 PyObject *resultobj = NULL;
36499 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36500 int arg2 ;
36501 wxString *arg3 = 0 ;
36502 bool temp3 = false ;
36503 PyObject * obj0 = 0 ;
36504 PyObject * obj1 = 0 ;
36505 PyObject * obj2 = 0 ;
36506 char *kwnames[] = {
36507 (char *) "self",(char *) "id",(char *) "label", NULL
36508 };
36509
36510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36512 if (SWIG_arg_fail(1)) SWIG_fail;
36513 {
36514 arg2 = static_cast<int >(SWIG_As_int(obj1));
36515 if (SWIG_arg_fail(2)) SWIG_fail;
36516 }
36517 {
36518 arg3 = wxString_in_helper(obj2);
36519 if (arg3 == NULL) SWIG_fail;
36520 temp3 = true;
36521 }
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36525
36526 wxPyEndAllowThreads(__tstate);
36527 if (PyErr_Occurred()) SWIG_fail;
36528 }
36529 Py_INCREF(Py_None); resultobj = Py_None;
36530 {
36531 if (temp3)
36532 delete arg3;
36533 }
36534 return resultobj;
36535 fail:
36536 {
36537 if (temp3)
36538 delete arg3;
36539 }
36540 return NULL;
36541 }
36542
36543
36544 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36545 PyObject *resultobj = NULL;
36546 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36547 int arg2 ;
36548 wxString result;
36549 PyObject * obj0 = 0 ;
36550 PyObject * obj1 = 0 ;
36551 char *kwnames[] = {
36552 (char *) "self",(char *) "id", NULL
36553 };
36554
36555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36557 if (SWIG_arg_fail(1)) SWIG_fail;
36558 {
36559 arg2 = static_cast<int >(SWIG_As_int(obj1));
36560 if (SWIG_arg_fail(2)) SWIG_fail;
36561 }
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36565
36566 wxPyEndAllowThreads(__tstate);
36567 if (PyErr_Occurred()) SWIG_fail;
36568 }
36569 {
36570 #if wxUSE_UNICODE
36571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36572 #else
36573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36574 #endif
36575 }
36576 return resultobj;
36577 fail:
36578 return NULL;
36579 }
36580
36581
36582 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36583 PyObject *resultobj = NULL;
36584 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36585 int arg2 ;
36586 wxString *arg3 = 0 ;
36587 bool temp3 = false ;
36588 PyObject * obj0 = 0 ;
36589 PyObject * obj1 = 0 ;
36590 PyObject * obj2 = 0 ;
36591 char *kwnames[] = {
36592 (char *) "self",(char *) "id",(char *) "helpString", NULL
36593 };
36594
36595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36597 if (SWIG_arg_fail(1)) SWIG_fail;
36598 {
36599 arg2 = static_cast<int >(SWIG_As_int(obj1));
36600 if (SWIG_arg_fail(2)) SWIG_fail;
36601 }
36602 {
36603 arg3 = wxString_in_helper(obj2);
36604 if (arg3 == NULL) SWIG_fail;
36605 temp3 = true;
36606 }
36607 {
36608 PyThreadState* __tstate = wxPyBeginAllowThreads();
36609 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36610
36611 wxPyEndAllowThreads(__tstate);
36612 if (PyErr_Occurred()) SWIG_fail;
36613 }
36614 Py_INCREF(Py_None); resultobj = Py_None;
36615 {
36616 if (temp3)
36617 delete arg3;
36618 }
36619 return resultobj;
36620 fail:
36621 {
36622 if (temp3)
36623 delete arg3;
36624 }
36625 return NULL;
36626 }
36627
36628
36629 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36630 PyObject *resultobj = NULL;
36631 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36632 int arg2 ;
36633 wxString result;
36634 PyObject * obj0 = 0 ;
36635 PyObject * obj1 = 0 ;
36636 char *kwnames[] = {
36637 (char *) "self",(char *) "id", NULL
36638 };
36639
36640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36642 if (SWIG_arg_fail(1)) SWIG_fail;
36643 {
36644 arg2 = static_cast<int >(SWIG_As_int(obj1));
36645 if (SWIG_arg_fail(2)) SWIG_fail;
36646 }
36647 {
36648 PyThreadState* __tstate = wxPyBeginAllowThreads();
36649 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36650
36651 wxPyEndAllowThreads(__tstate);
36652 if (PyErr_Occurred()) SWIG_fail;
36653 }
36654 {
36655 #if wxUSE_UNICODE
36656 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36657 #else
36658 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36659 #endif
36660 }
36661 return resultobj;
36662 fail:
36663 return NULL;
36664 }
36665
36666
36667 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36668 PyObject *resultobj = NULL;
36669 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36670 wxFrame *result;
36671 PyObject * obj0 = 0 ;
36672 char *kwnames[] = {
36673 (char *) "self", NULL
36674 };
36675
36676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36678 if (SWIG_arg_fail(1)) SWIG_fail;
36679 {
36680 PyThreadState* __tstate = wxPyBeginAllowThreads();
36681 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36682
36683 wxPyEndAllowThreads(__tstate);
36684 if (PyErr_Occurred()) SWIG_fail;
36685 }
36686 {
36687 resultobj = wxPyMake_wxObject(result, (bool)0);
36688 }
36689 return resultobj;
36690 fail:
36691 return NULL;
36692 }
36693
36694
36695 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36696 PyObject *resultobj = NULL;
36697 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36698 bool result;
36699 PyObject * obj0 = 0 ;
36700 char *kwnames[] = {
36701 (char *) "self", NULL
36702 };
36703
36704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36706 if (SWIG_arg_fail(1)) SWIG_fail;
36707 {
36708 PyThreadState* __tstate = wxPyBeginAllowThreads();
36709 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36710
36711 wxPyEndAllowThreads(__tstate);
36712 if (PyErr_Occurred()) SWIG_fail;
36713 }
36714 {
36715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36716 }
36717 return resultobj;
36718 fail:
36719 return NULL;
36720 }
36721
36722
36723 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36724 PyObject *resultobj = NULL;
36725 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36726 wxFrame *arg2 = (wxFrame *) 0 ;
36727 PyObject * obj0 = 0 ;
36728 PyObject * obj1 = 0 ;
36729 char *kwnames[] = {
36730 (char *) "self",(char *) "frame", NULL
36731 };
36732
36733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36735 if (SWIG_arg_fail(1)) SWIG_fail;
36736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36737 if (SWIG_arg_fail(2)) SWIG_fail;
36738 {
36739 PyThreadState* __tstate = wxPyBeginAllowThreads();
36740 (arg1)->Attach(arg2);
36741
36742 wxPyEndAllowThreads(__tstate);
36743 if (PyErr_Occurred()) SWIG_fail;
36744 }
36745 Py_INCREF(Py_None); resultobj = Py_None;
36746 return resultobj;
36747 fail:
36748 return NULL;
36749 }
36750
36751
36752 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36753 PyObject *resultobj = NULL;
36754 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36755 PyObject * obj0 = 0 ;
36756 char *kwnames[] = {
36757 (char *) "self", NULL
36758 };
36759
36760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36762 if (SWIG_arg_fail(1)) SWIG_fail;
36763 {
36764 PyThreadState* __tstate = wxPyBeginAllowThreads();
36765 (arg1)->Detach();
36766
36767 wxPyEndAllowThreads(__tstate);
36768 if (PyErr_Occurred()) SWIG_fail;
36769 }
36770 Py_INCREF(Py_None); resultobj = Py_None;
36771 return resultobj;
36772 fail:
36773 return NULL;
36774 }
36775
36776
36777 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36778 PyObject *resultobj = NULL;
36779 bool arg1 ;
36780 PyObject * obj0 = 0 ;
36781 char *kwnames[] = {
36782 (char *) "enable", NULL
36783 };
36784
36785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36786 {
36787 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36788 if (SWIG_arg_fail(1)) SWIG_fail;
36789 }
36790 {
36791 PyThreadState* __tstate = wxPyBeginAllowThreads();
36792 wxMenuBar_SetAutoWindowMenu(arg1);
36793
36794 wxPyEndAllowThreads(__tstate);
36795 if (PyErr_Occurred()) SWIG_fail;
36796 }
36797 Py_INCREF(Py_None); resultobj = Py_None;
36798 return resultobj;
36799 fail:
36800 return NULL;
36801 }
36802
36803
36804 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36805 PyObject *resultobj = NULL;
36806 bool result;
36807 char *kwnames[] = {
36808 NULL
36809 };
36810
36811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36812 {
36813 PyThreadState* __tstate = wxPyBeginAllowThreads();
36814 result = (bool)wxMenuBar_GetAutoWindowMenu();
36815
36816 wxPyEndAllowThreads(__tstate);
36817 if (PyErr_Occurred()) SWIG_fail;
36818 }
36819 {
36820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36821 }
36822 return resultobj;
36823 fail:
36824 return NULL;
36825 }
36826
36827
36828 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36829 PyObject *obj;
36830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36831 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36832 Py_INCREF(obj);
36833 return Py_BuildValue((char *)"");
36834 }
36835 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36836 PyObject *resultobj = NULL;
36837 wxMenu *arg1 = (wxMenu *) NULL ;
36838 int arg2 = (int) wxID_ANY ;
36839 wxString const &arg3_defvalue = wxPyEmptyString ;
36840 wxString *arg3 = (wxString *) &arg3_defvalue ;
36841 wxString const &arg4_defvalue = wxPyEmptyString ;
36842 wxString *arg4 = (wxString *) &arg4_defvalue ;
36843 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36844 wxMenu *arg6 = (wxMenu *) NULL ;
36845 wxMenuItem *result;
36846 bool temp3 = false ;
36847 bool temp4 = false ;
36848 PyObject * obj0 = 0 ;
36849 PyObject * obj1 = 0 ;
36850 PyObject * obj2 = 0 ;
36851 PyObject * obj3 = 0 ;
36852 PyObject * obj4 = 0 ;
36853 PyObject * obj5 = 0 ;
36854 char *kwnames[] = {
36855 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36856 };
36857
36858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36859 if (obj0) {
36860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36861 if (SWIG_arg_fail(1)) SWIG_fail;
36862 }
36863 if (obj1) {
36864 {
36865 arg2 = static_cast<int >(SWIG_As_int(obj1));
36866 if (SWIG_arg_fail(2)) SWIG_fail;
36867 }
36868 }
36869 if (obj2) {
36870 {
36871 arg3 = wxString_in_helper(obj2);
36872 if (arg3 == NULL) SWIG_fail;
36873 temp3 = true;
36874 }
36875 }
36876 if (obj3) {
36877 {
36878 arg4 = wxString_in_helper(obj3);
36879 if (arg4 == NULL) SWIG_fail;
36880 temp4 = true;
36881 }
36882 }
36883 if (obj4) {
36884 {
36885 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36886 if (SWIG_arg_fail(5)) SWIG_fail;
36887 }
36888 }
36889 if (obj5) {
36890 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36891 if (SWIG_arg_fail(6)) SWIG_fail;
36892 }
36893 {
36894 PyThreadState* __tstate = wxPyBeginAllowThreads();
36895 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36896
36897 wxPyEndAllowThreads(__tstate);
36898 if (PyErr_Occurred()) SWIG_fail;
36899 }
36900 {
36901 resultobj = wxPyMake_wxObject(result, (bool)1);
36902 }
36903 {
36904 if (temp3)
36905 delete arg3;
36906 }
36907 {
36908 if (temp4)
36909 delete arg4;
36910 }
36911 return resultobj;
36912 fail:
36913 {
36914 if (temp3)
36915 delete arg3;
36916 }
36917 {
36918 if (temp4)
36919 delete arg4;
36920 }
36921 return NULL;
36922 }
36923
36924
36925 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36926 PyObject *resultobj = NULL;
36927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36928 wxMenu *result;
36929 PyObject * obj0 = 0 ;
36930 char *kwnames[] = {
36931 (char *) "self", NULL
36932 };
36933
36934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36936 if (SWIG_arg_fail(1)) SWIG_fail;
36937 {
36938 PyThreadState* __tstate = wxPyBeginAllowThreads();
36939 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36940
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 {
36945 resultobj = wxPyMake_wxObject(result, 0);
36946 }
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36954 PyObject *resultobj = NULL;
36955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36956 wxMenu *arg2 = (wxMenu *) 0 ;
36957 PyObject * obj0 = 0 ;
36958 PyObject * obj1 = 0 ;
36959 char *kwnames[] = {
36960 (char *) "self",(char *) "menu", NULL
36961 };
36962
36963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36965 if (SWIG_arg_fail(1)) SWIG_fail;
36966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36967 if (SWIG_arg_fail(2)) SWIG_fail;
36968 {
36969 PyThreadState* __tstate = wxPyBeginAllowThreads();
36970 (arg1)->SetMenu(arg2);
36971
36972 wxPyEndAllowThreads(__tstate);
36973 if (PyErr_Occurred()) SWIG_fail;
36974 }
36975 Py_INCREF(Py_None); resultobj = Py_None;
36976 return resultobj;
36977 fail:
36978 return NULL;
36979 }
36980
36981
36982 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36983 PyObject *resultobj = NULL;
36984 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36985 int arg2 ;
36986 PyObject * obj0 = 0 ;
36987 PyObject * obj1 = 0 ;
36988 char *kwnames[] = {
36989 (char *) "self",(char *) "id", NULL
36990 };
36991
36992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36994 if (SWIG_arg_fail(1)) SWIG_fail;
36995 {
36996 arg2 = static_cast<int >(SWIG_As_int(obj1));
36997 if (SWIG_arg_fail(2)) SWIG_fail;
36998 }
36999 {
37000 PyThreadState* __tstate = wxPyBeginAllowThreads();
37001 (arg1)->SetId(arg2);
37002
37003 wxPyEndAllowThreads(__tstate);
37004 if (PyErr_Occurred()) SWIG_fail;
37005 }
37006 Py_INCREF(Py_None); resultobj = Py_None;
37007 return resultobj;
37008 fail:
37009 return NULL;
37010 }
37011
37012
37013 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
37014 PyObject *resultobj = NULL;
37015 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37016 int result;
37017 PyObject * obj0 = 0 ;
37018 char *kwnames[] = {
37019 (char *) "self", NULL
37020 };
37021
37022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
37023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37024 if (SWIG_arg_fail(1)) SWIG_fail;
37025 {
37026 PyThreadState* __tstate = wxPyBeginAllowThreads();
37027 result = (int)((wxMenuItem const *)arg1)->GetId();
37028
37029 wxPyEndAllowThreads(__tstate);
37030 if (PyErr_Occurred()) SWIG_fail;
37031 }
37032 {
37033 resultobj = SWIG_From_int(static_cast<int >(result));
37034 }
37035 return resultobj;
37036 fail:
37037 return NULL;
37038 }
37039
37040
37041 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
37042 PyObject *resultobj = NULL;
37043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37044 bool result;
37045 PyObject * obj0 = 0 ;
37046 char *kwnames[] = {
37047 (char *) "self", NULL
37048 };
37049
37050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
37051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37052 if (SWIG_arg_fail(1)) SWIG_fail;
37053 {
37054 PyThreadState* __tstate = wxPyBeginAllowThreads();
37055 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
37056
37057 wxPyEndAllowThreads(__tstate);
37058 if (PyErr_Occurred()) SWIG_fail;
37059 }
37060 {
37061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37062 }
37063 return resultobj;
37064 fail:
37065 return NULL;
37066 }
37067
37068
37069 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
37070 PyObject *resultobj = NULL;
37071 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37072 wxString *arg2 = 0 ;
37073 bool temp2 = false ;
37074 PyObject * obj0 = 0 ;
37075 PyObject * obj1 = 0 ;
37076 char *kwnames[] = {
37077 (char *) "self",(char *) "str", NULL
37078 };
37079
37080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37082 if (SWIG_arg_fail(1)) SWIG_fail;
37083 {
37084 arg2 = wxString_in_helper(obj1);
37085 if (arg2 == NULL) SWIG_fail;
37086 temp2 = true;
37087 }
37088 {
37089 PyThreadState* __tstate = wxPyBeginAllowThreads();
37090 (arg1)->SetText((wxString const &)*arg2);
37091
37092 wxPyEndAllowThreads(__tstate);
37093 if (PyErr_Occurred()) SWIG_fail;
37094 }
37095 Py_INCREF(Py_None); resultobj = Py_None;
37096 {
37097 if (temp2)
37098 delete arg2;
37099 }
37100 return resultobj;
37101 fail:
37102 {
37103 if (temp2)
37104 delete arg2;
37105 }
37106 return NULL;
37107 }
37108
37109
37110 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37111 PyObject *resultobj = NULL;
37112 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37113 wxString result;
37114 PyObject * obj0 = 0 ;
37115 char *kwnames[] = {
37116 (char *) "self", NULL
37117 };
37118
37119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37121 if (SWIG_arg_fail(1)) SWIG_fail;
37122 {
37123 PyThreadState* __tstate = wxPyBeginAllowThreads();
37124 result = ((wxMenuItem const *)arg1)->GetLabel();
37125
37126 wxPyEndAllowThreads(__tstate);
37127 if (PyErr_Occurred()) SWIG_fail;
37128 }
37129 {
37130 #if wxUSE_UNICODE
37131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37132 #else
37133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37134 #endif
37135 }
37136 return resultobj;
37137 fail:
37138 return NULL;
37139 }
37140
37141
37142 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37143 PyObject *resultobj = NULL;
37144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37145 wxString *result;
37146 PyObject * obj0 = 0 ;
37147 char *kwnames[] = {
37148 (char *) "self", NULL
37149 };
37150
37151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37153 if (SWIG_arg_fail(1)) SWIG_fail;
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 {
37157 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37158 result = (wxString *) &_result_ref;
37159 }
37160
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 {
37165 #if wxUSE_UNICODE
37166 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37167 #else
37168 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37169 #endif
37170 }
37171 return resultobj;
37172 fail:
37173 return NULL;
37174 }
37175
37176
37177 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37178 PyObject *resultobj = NULL;
37179 wxString *arg1 = 0 ;
37180 wxString result;
37181 bool temp1 = false ;
37182 PyObject * obj0 = 0 ;
37183 char *kwnames[] = {
37184 (char *) "text", NULL
37185 };
37186
37187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37188 {
37189 arg1 = wxString_in_helper(obj0);
37190 if (arg1 == NULL) SWIG_fail;
37191 temp1 = true;
37192 }
37193 {
37194 PyThreadState* __tstate = wxPyBeginAllowThreads();
37195 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37196
37197 wxPyEndAllowThreads(__tstate);
37198 if (PyErr_Occurred()) SWIG_fail;
37199 }
37200 {
37201 #if wxUSE_UNICODE
37202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37203 #else
37204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37205 #endif
37206 }
37207 {
37208 if (temp1)
37209 delete arg1;
37210 }
37211 return resultobj;
37212 fail:
37213 {
37214 if (temp1)
37215 delete arg1;
37216 }
37217 return NULL;
37218 }
37219
37220
37221 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37222 PyObject *resultobj = NULL;
37223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37224 wxItemKind result;
37225 PyObject * obj0 = 0 ;
37226 char *kwnames[] = {
37227 (char *) "self", NULL
37228 };
37229
37230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37232 if (SWIG_arg_fail(1)) SWIG_fail;
37233 {
37234 PyThreadState* __tstate = wxPyBeginAllowThreads();
37235 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37236
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 resultobj = SWIG_From_int((result));
37241 return resultobj;
37242 fail:
37243 return NULL;
37244 }
37245
37246
37247 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37248 PyObject *resultobj = NULL;
37249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37250 wxItemKind arg2 ;
37251 PyObject * obj0 = 0 ;
37252 PyObject * obj1 = 0 ;
37253 char *kwnames[] = {
37254 (char *) "self",(char *) "kind", NULL
37255 };
37256
37257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37259 if (SWIG_arg_fail(1)) SWIG_fail;
37260 {
37261 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37262 if (SWIG_arg_fail(2)) SWIG_fail;
37263 }
37264 {
37265 PyThreadState* __tstate = wxPyBeginAllowThreads();
37266 (arg1)->SetKind(arg2);
37267
37268 wxPyEndAllowThreads(__tstate);
37269 if (PyErr_Occurred()) SWIG_fail;
37270 }
37271 Py_INCREF(Py_None); resultobj = Py_None;
37272 return resultobj;
37273 fail:
37274 return NULL;
37275 }
37276
37277
37278 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37279 PyObject *resultobj = NULL;
37280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37281 bool arg2 ;
37282 PyObject * obj0 = 0 ;
37283 PyObject * obj1 = 0 ;
37284 char *kwnames[] = {
37285 (char *) "self",(char *) "checkable", NULL
37286 };
37287
37288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37290 if (SWIG_arg_fail(1)) SWIG_fail;
37291 {
37292 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37293 if (SWIG_arg_fail(2)) SWIG_fail;
37294 }
37295 {
37296 PyThreadState* __tstate = wxPyBeginAllowThreads();
37297 (arg1)->SetCheckable(arg2);
37298
37299 wxPyEndAllowThreads(__tstate);
37300 if (PyErr_Occurred()) SWIG_fail;
37301 }
37302 Py_INCREF(Py_None); resultobj = Py_None;
37303 return resultobj;
37304 fail:
37305 return NULL;
37306 }
37307
37308
37309 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37310 PyObject *resultobj = NULL;
37311 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37312 bool result;
37313 PyObject * obj0 = 0 ;
37314 char *kwnames[] = {
37315 (char *) "self", NULL
37316 };
37317
37318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
37323 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37324
37325 wxPyEndAllowThreads(__tstate);
37326 if (PyErr_Occurred()) SWIG_fail;
37327 }
37328 {
37329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37330 }
37331 return resultobj;
37332 fail:
37333 return NULL;
37334 }
37335
37336
37337 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37338 PyObject *resultobj = NULL;
37339 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37340 bool result;
37341 PyObject * obj0 = 0 ;
37342 char *kwnames[] = {
37343 (char *) "self", NULL
37344 };
37345
37346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37348 if (SWIG_arg_fail(1)) SWIG_fail;
37349 {
37350 PyThreadState* __tstate = wxPyBeginAllowThreads();
37351 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37352
37353 wxPyEndAllowThreads(__tstate);
37354 if (PyErr_Occurred()) SWIG_fail;
37355 }
37356 {
37357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37358 }
37359 return resultobj;
37360 fail:
37361 return NULL;
37362 }
37363
37364
37365 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37366 PyObject *resultobj = NULL;
37367 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37368 wxMenu *arg2 = (wxMenu *) 0 ;
37369 PyObject * obj0 = 0 ;
37370 PyObject * obj1 = 0 ;
37371 char *kwnames[] = {
37372 (char *) "self",(char *) "menu", NULL
37373 };
37374
37375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37377 if (SWIG_arg_fail(1)) SWIG_fail;
37378 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37379 if (SWIG_arg_fail(2)) SWIG_fail;
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 (arg1)->SetSubMenu(arg2);
37383
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 Py_INCREF(Py_None); resultobj = Py_None;
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37395 PyObject *resultobj = NULL;
37396 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37397 wxMenu *result;
37398 PyObject * obj0 = 0 ;
37399 char *kwnames[] = {
37400 (char *) "self", NULL
37401 };
37402
37403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37405 if (SWIG_arg_fail(1)) SWIG_fail;
37406 {
37407 PyThreadState* __tstate = wxPyBeginAllowThreads();
37408 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37409
37410 wxPyEndAllowThreads(__tstate);
37411 if (PyErr_Occurred()) SWIG_fail;
37412 }
37413 {
37414 resultobj = wxPyMake_wxObject(result, 0);
37415 }
37416 return resultobj;
37417 fail:
37418 return NULL;
37419 }
37420
37421
37422 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37423 PyObject *resultobj = NULL;
37424 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37425 bool arg2 = (bool) true ;
37426 PyObject * obj0 = 0 ;
37427 PyObject * obj1 = 0 ;
37428 char *kwnames[] = {
37429 (char *) "self",(char *) "enable", NULL
37430 };
37431
37432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37434 if (SWIG_arg_fail(1)) SWIG_fail;
37435 if (obj1) {
37436 {
37437 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37438 if (SWIG_arg_fail(2)) SWIG_fail;
37439 }
37440 }
37441 {
37442 PyThreadState* __tstate = wxPyBeginAllowThreads();
37443 (arg1)->Enable(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_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37456 PyObject *resultobj = NULL;
37457 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37458 bool result;
37459 PyObject * obj0 = 0 ;
37460 char *kwnames[] = {
37461 (char *) "self", NULL
37462 };
37463
37464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",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 = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37470
37471 wxPyEndAllowThreads(__tstate);
37472 if (PyErr_Occurred()) SWIG_fail;
37473 }
37474 {
37475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37476 }
37477 return resultobj;
37478 fail:
37479 return NULL;
37480 }
37481
37482
37483 static PyObject *_wrap_MenuItem_Check(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 *) "check", NULL
37491 };
37492
37493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",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)->Check(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_IsChecked(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_IsChecked",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)->IsChecked();
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_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37545 PyObject *resultobj = NULL;
37546 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37547 PyObject * obj0 = 0 ;
37548 char *kwnames[] = {
37549 (char *) "self", NULL
37550 };
37551
37552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37554 if (SWIG_arg_fail(1)) SWIG_fail;
37555 {
37556 PyThreadState* __tstate = wxPyBeginAllowThreads();
37557 (arg1)->Toggle();
37558
37559 wxPyEndAllowThreads(__tstate);
37560 if (PyErr_Occurred()) SWIG_fail;
37561 }
37562 Py_INCREF(Py_None); resultobj = Py_None;
37563 return resultobj;
37564 fail:
37565 return NULL;
37566 }
37567
37568
37569 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37570 PyObject *resultobj = NULL;
37571 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37572 wxString *arg2 = 0 ;
37573 bool temp2 = false ;
37574 PyObject * obj0 = 0 ;
37575 PyObject * obj1 = 0 ;
37576 char *kwnames[] = {
37577 (char *) "self",(char *) "str", NULL
37578 };
37579
37580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37582 if (SWIG_arg_fail(1)) SWIG_fail;
37583 {
37584 arg2 = wxString_in_helper(obj1);
37585 if (arg2 == NULL) SWIG_fail;
37586 temp2 = true;
37587 }
37588 {
37589 PyThreadState* __tstate = wxPyBeginAllowThreads();
37590 (arg1)->SetHelp((wxString const &)*arg2);
37591
37592 wxPyEndAllowThreads(__tstate);
37593 if (PyErr_Occurred()) SWIG_fail;
37594 }
37595 Py_INCREF(Py_None); resultobj = Py_None;
37596 {
37597 if (temp2)
37598 delete arg2;
37599 }
37600 return resultobj;
37601 fail:
37602 {
37603 if (temp2)
37604 delete arg2;
37605 }
37606 return NULL;
37607 }
37608
37609
37610 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37611 PyObject *resultobj = NULL;
37612 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37613 wxString *result;
37614 PyObject * obj0 = 0 ;
37615 char *kwnames[] = {
37616 (char *) "self", NULL
37617 };
37618
37619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37621 if (SWIG_arg_fail(1)) SWIG_fail;
37622 {
37623 PyThreadState* __tstate = wxPyBeginAllowThreads();
37624 {
37625 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37626 result = (wxString *) &_result_ref;
37627 }
37628
37629 wxPyEndAllowThreads(__tstate);
37630 if (PyErr_Occurred()) SWIG_fail;
37631 }
37632 {
37633 #if wxUSE_UNICODE
37634 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37635 #else
37636 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37637 #endif
37638 }
37639 return resultobj;
37640 fail:
37641 return NULL;
37642 }
37643
37644
37645 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37646 PyObject *resultobj = NULL;
37647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37648 wxAcceleratorEntry *result;
37649 PyObject * obj0 = 0 ;
37650 char *kwnames[] = {
37651 (char *) "self", NULL
37652 };
37653
37654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37656 if (SWIG_arg_fail(1)) SWIG_fail;
37657 {
37658 PyThreadState* __tstate = wxPyBeginAllowThreads();
37659 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37660
37661 wxPyEndAllowThreads(__tstate);
37662 if (PyErr_Occurred()) SWIG_fail;
37663 }
37664 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37665 return resultobj;
37666 fail:
37667 return NULL;
37668 }
37669
37670
37671 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37672 PyObject *resultobj = NULL;
37673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37674 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37675 PyObject * obj0 = 0 ;
37676 PyObject * obj1 = 0 ;
37677 char *kwnames[] = {
37678 (char *) "self",(char *) "accel", NULL
37679 };
37680
37681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37683 if (SWIG_arg_fail(1)) SWIG_fail;
37684 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37685 if (SWIG_arg_fail(2)) SWIG_fail;
37686 {
37687 PyThreadState* __tstate = wxPyBeginAllowThreads();
37688 (arg1)->SetAccel(arg2);
37689
37690 wxPyEndAllowThreads(__tstate);
37691 if (PyErr_Occurred()) SWIG_fail;
37692 }
37693 Py_INCREF(Py_None); resultobj = Py_None;
37694 return resultobj;
37695 fail:
37696 return NULL;
37697 }
37698
37699
37700 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37701 PyObject *resultobj = NULL;
37702 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37703 wxBitmap *arg2 = 0 ;
37704 PyObject * obj0 = 0 ;
37705 PyObject * obj1 = 0 ;
37706 char *kwnames[] = {
37707 (char *) "self",(char *) "bitmap", NULL
37708 };
37709
37710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37712 if (SWIG_arg_fail(1)) SWIG_fail;
37713 {
37714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37715 if (SWIG_arg_fail(2)) SWIG_fail;
37716 if (arg2 == NULL) {
37717 SWIG_null_ref("wxBitmap");
37718 }
37719 if (SWIG_arg_fail(2)) SWIG_fail;
37720 }
37721 {
37722 PyThreadState* __tstate = wxPyBeginAllowThreads();
37723 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37724
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 Py_INCREF(Py_None); resultobj = Py_None;
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37736 PyObject *resultobj = NULL;
37737 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37738 wxBitmap *result;
37739 PyObject * obj0 = 0 ;
37740 char *kwnames[] = {
37741 (char *) "self", NULL
37742 };
37743
37744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37746 if (SWIG_arg_fail(1)) SWIG_fail;
37747 {
37748 PyThreadState* __tstate = wxPyBeginAllowThreads();
37749 {
37750 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37751 result = (wxBitmap *) &_result_ref;
37752 }
37753
37754 wxPyEndAllowThreads(__tstate);
37755 if (PyErr_Occurred()) SWIG_fail;
37756 }
37757 {
37758 wxBitmap* resultptr = new wxBitmap(*result);
37759 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37760 }
37761 return resultobj;
37762 fail:
37763 return NULL;
37764 }
37765
37766
37767 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37768 PyObject *resultobj = NULL;
37769 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37770 wxFont *arg2 = 0 ;
37771 PyObject * obj0 = 0 ;
37772 PyObject * obj1 = 0 ;
37773 char *kwnames[] = {
37774 (char *) "self",(char *) "font", NULL
37775 };
37776
37777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37779 if (SWIG_arg_fail(1)) SWIG_fail;
37780 {
37781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37782 if (SWIG_arg_fail(2)) SWIG_fail;
37783 if (arg2 == NULL) {
37784 SWIG_null_ref("wxFont");
37785 }
37786 if (SWIG_arg_fail(2)) SWIG_fail;
37787 }
37788 {
37789 PyThreadState* __tstate = wxPyBeginAllowThreads();
37790 (arg1)->SetFont((wxFont const &)*arg2);
37791
37792 wxPyEndAllowThreads(__tstate);
37793 if (PyErr_Occurred()) SWIG_fail;
37794 }
37795 Py_INCREF(Py_None); resultobj = Py_None;
37796 return resultobj;
37797 fail:
37798 return NULL;
37799 }
37800
37801
37802 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37803 PyObject *resultobj = NULL;
37804 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37805 wxFont result;
37806 PyObject * obj0 = 0 ;
37807 char *kwnames[] = {
37808 (char *) "self", NULL
37809 };
37810
37811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37813 if (SWIG_arg_fail(1)) SWIG_fail;
37814 {
37815 PyThreadState* __tstate = wxPyBeginAllowThreads();
37816 result = (arg1)->GetFont();
37817
37818 wxPyEndAllowThreads(__tstate);
37819 if (PyErr_Occurred()) SWIG_fail;
37820 }
37821 {
37822 wxFont * resultptr;
37823 resultptr = new wxFont(static_cast<wxFont & >(result));
37824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37825 }
37826 return resultobj;
37827 fail:
37828 return NULL;
37829 }
37830
37831
37832 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37833 PyObject *resultobj = NULL;
37834 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37835 wxColour *arg2 = 0 ;
37836 wxColour temp2 ;
37837 PyObject * obj0 = 0 ;
37838 PyObject * obj1 = 0 ;
37839 char *kwnames[] = {
37840 (char *) "self",(char *) "colText", NULL
37841 };
37842
37843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37845 if (SWIG_arg_fail(1)) SWIG_fail;
37846 {
37847 arg2 = &temp2;
37848 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37849 }
37850 {
37851 PyThreadState* __tstate = wxPyBeginAllowThreads();
37852 (arg1)->SetTextColour((wxColour const &)*arg2);
37853
37854 wxPyEndAllowThreads(__tstate);
37855 if (PyErr_Occurred()) SWIG_fail;
37856 }
37857 Py_INCREF(Py_None); resultobj = Py_None;
37858 return resultobj;
37859 fail:
37860 return NULL;
37861 }
37862
37863
37864 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37865 PyObject *resultobj = NULL;
37866 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37867 wxColour result;
37868 PyObject * obj0 = 0 ;
37869 char *kwnames[] = {
37870 (char *) "self", NULL
37871 };
37872
37873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37875 if (SWIG_arg_fail(1)) SWIG_fail;
37876 {
37877 PyThreadState* __tstate = wxPyBeginAllowThreads();
37878 result = (arg1)->GetTextColour();
37879
37880 wxPyEndAllowThreads(__tstate);
37881 if (PyErr_Occurred()) SWIG_fail;
37882 }
37883 {
37884 wxColour * resultptr;
37885 resultptr = new wxColour(static_cast<wxColour & >(result));
37886 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37887 }
37888 return resultobj;
37889 fail:
37890 return NULL;
37891 }
37892
37893
37894 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37895 PyObject *resultobj = NULL;
37896 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37897 wxColour *arg2 = 0 ;
37898 wxColour temp2 ;
37899 PyObject * obj0 = 0 ;
37900 PyObject * obj1 = 0 ;
37901 char *kwnames[] = {
37902 (char *) "self",(char *) "colBack", NULL
37903 };
37904
37905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37907 if (SWIG_arg_fail(1)) SWIG_fail;
37908 {
37909 arg2 = &temp2;
37910 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37911 }
37912 {
37913 PyThreadState* __tstate = wxPyBeginAllowThreads();
37914 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
37915
37916 wxPyEndAllowThreads(__tstate);
37917 if (PyErr_Occurred()) SWIG_fail;
37918 }
37919 Py_INCREF(Py_None); resultobj = Py_None;
37920 return resultobj;
37921 fail:
37922 return NULL;
37923 }
37924
37925
37926 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37927 PyObject *resultobj = NULL;
37928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37929 wxColour result;
37930 PyObject * obj0 = 0 ;
37931 char *kwnames[] = {
37932 (char *) "self", NULL
37933 };
37934
37935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37937 if (SWIG_arg_fail(1)) SWIG_fail;
37938 {
37939 PyThreadState* __tstate = wxPyBeginAllowThreads();
37940 result = (arg1)->GetBackgroundColour();
37941
37942 wxPyEndAllowThreads(__tstate);
37943 if (PyErr_Occurred()) SWIG_fail;
37944 }
37945 {
37946 wxColour * resultptr;
37947 resultptr = new wxColour(static_cast<wxColour & >(result));
37948 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37949 }
37950 return resultobj;
37951 fail:
37952 return NULL;
37953 }
37954
37955
37956 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37957 PyObject *resultobj = NULL;
37958 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37959 wxBitmap *arg2 = 0 ;
37960 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37961 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37962 PyObject * obj0 = 0 ;
37963 PyObject * obj1 = 0 ;
37964 PyObject * obj2 = 0 ;
37965 char *kwnames[] = {
37966 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37967 };
37968
37969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37971 if (SWIG_arg_fail(1)) SWIG_fail;
37972 {
37973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37974 if (SWIG_arg_fail(2)) SWIG_fail;
37975 if (arg2 == NULL) {
37976 SWIG_null_ref("wxBitmap");
37977 }
37978 if (SWIG_arg_fail(2)) SWIG_fail;
37979 }
37980 if (obj2) {
37981 {
37982 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37983 if (SWIG_arg_fail(3)) SWIG_fail;
37984 if (arg3 == NULL) {
37985 SWIG_null_ref("wxBitmap");
37986 }
37987 if (SWIG_arg_fail(3)) SWIG_fail;
37988 }
37989 }
37990 {
37991 PyThreadState* __tstate = wxPyBeginAllowThreads();
37992 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37993
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 Py_INCREF(Py_None); resultobj = Py_None;
37998 return resultobj;
37999 fail:
38000 return NULL;
38001 }
38002
38003
38004 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
38005 PyObject *resultobj = NULL;
38006 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38007 wxBitmap *arg2 = 0 ;
38008 PyObject * obj0 = 0 ;
38009 PyObject * obj1 = 0 ;
38010 char *kwnames[] = {
38011 (char *) "self",(char *) "bmpDisabled", NULL
38012 };
38013
38014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
38015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38016 if (SWIG_arg_fail(1)) SWIG_fail;
38017 {
38018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
38019 if (SWIG_arg_fail(2)) SWIG_fail;
38020 if (arg2 == NULL) {
38021 SWIG_null_ref("wxBitmap");
38022 }
38023 if (SWIG_arg_fail(2)) SWIG_fail;
38024 }
38025 {
38026 PyThreadState* __tstate = wxPyBeginAllowThreads();
38027 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
38028
38029 wxPyEndAllowThreads(__tstate);
38030 if (PyErr_Occurred()) SWIG_fail;
38031 }
38032 Py_INCREF(Py_None); resultobj = Py_None;
38033 return resultobj;
38034 fail:
38035 return NULL;
38036 }
38037
38038
38039 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
38040 PyObject *resultobj = NULL;
38041 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38042 wxBitmap *result;
38043 PyObject * obj0 = 0 ;
38044 char *kwnames[] = {
38045 (char *) "self", NULL
38046 };
38047
38048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
38049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38050 if (SWIG_arg_fail(1)) SWIG_fail;
38051 {
38052 PyThreadState* __tstate = wxPyBeginAllowThreads();
38053 {
38054 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
38055 result = (wxBitmap *) &_result_ref;
38056 }
38057
38058 wxPyEndAllowThreads(__tstate);
38059 if (PyErr_Occurred()) SWIG_fail;
38060 }
38061 {
38062 wxBitmap* resultptr = new wxBitmap(*result);
38063 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
38064 }
38065 return resultobj;
38066 fail:
38067 return NULL;
38068 }
38069
38070
38071 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38072 PyObject *resultobj = NULL;
38073 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38074 int arg2 ;
38075 PyObject * obj0 = 0 ;
38076 PyObject * obj1 = 0 ;
38077 char *kwnames[] = {
38078 (char *) "self",(char *) "nWidth", NULL
38079 };
38080
38081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38083 if (SWIG_arg_fail(1)) SWIG_fail;
38084 {
38085 arg2 = static_cast<int >(SWIG_As_int(obj1));
38086 if (SWIG_arg_fail(2)) SWIG_fail;
38087 }
38088 {
38089 PyThreadState* __tstate = wxPyBeginAllowThreads();
38090 (arg1)->SetMarginWidth(arg2);
38091
38092 wxPyEndAllowThreads(__tstate);
38093 if (PyErr_Occurred()) SWIG_fail;
38094 }
38095 Py_INCREF(Py_None); resultobj = Py_None;
38096 return resultobj;
38097 fail:
38098 return NULL;
38099 }
38100
38101
38102 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38103 PyObject *resultobj = NULL;
38104 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38105 int result;
38106 PyObject * obj0 = 0 ;
38107 char *kwnames[] = {
38108 (char *) "self", NULL
38109 };
38110
38111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38113 if (SWIG_arg_fail(1)) SWIG_fail;
38114 {
38115 PyThreadState* __tstate = wxPyBeginAllowThreads();
38116 result = (int)(arg1)->GetMarginWidth();
38117
38118 wxPyEndAllowThreads(__tstate);
38119 if (PyErr_Occurred()) SWIG_fail;
38120 }
38121 {
38122 resultobj = SWIG_From_int(static_cast<int >(result));
38123 }
38124 return resultobj;
38125 fail:
38126 return NULL;
38127 }
38128
38129
38130 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38131 PyObject *resultobj = NULL;
38132 int result;
38133 char *kwnames[] = {
38134 NULL
38135 };
38136
38137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38138 {
38139 PyThreadState* __tstate = wxPyBeginAllowThreads();
38140 result = (int)wxMenuItem::GetDefaultMarginWidth();
38141
38142 wxPyEndAllowThreads(__tstate);
38143 if (PyErr_Occurred()) SWIG_fail;
38144 }
38145 {
38146 resultobj = SWIG_From_int(static_cast<int >(result));
38147 }
38148 return resultobj;
38149 fail:
38150 return NULL;
38151 }
38152
38153
38154 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38155 PyObject *resultobj = NULL;
38156 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38157 bool result;
38158 PyObject * obj0 = 0 ;
38159 char *kwnames[] = {
38160 (char *) "self", NULL
38161 };
38162
38163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38165 if (SWIG_arg_fail(1)) SWIG_fail;
38166 {
38167 PyThreadState* __tstate = wxPyBeginAllowThreads();
38168 result = (bool)(arg1)->IsOwnerDrawn();
38169
38170 wxPyEndAllowThreads(__tstate);
38171 if (PyErr_Occurred()) SWIG_fail;
38172 }
38173 {
38174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38175 }
38176 return resultobj;
38177 fail:
38178 return NULL;
38179 }
38180
38181
38182 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38183 PyObject *resultobj = NULL;
38184 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38185 bool arg2 = (bool) true ;
38186 PyObject * obj0 = 0 ;
38187 PyObject * obj1 = 0 ;
38188 char *kwnames[] = {
38189 (char *) "self",(char *) "ownerDrawn", NULL
38190 };
38191
38192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38194 if (SWIG_arg_fail(1)) SWIG_fail;
38195 if (obj1) {
38196 {
38197 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38198 if (SWIG_arg_fail(2)) SWIG_fail;
38199 }
38200 }
38201 {
38202 PyThreadState* __tstate = wxPyBeginAllowThreads();
38203 (arg1)->SetOwnerDrawn(arg2);
38204
38205 wxPyEndAllowThreads(__tstate);
38206 if (PyErr_Occurred()) SWIG_fail;
38207 }
38208 Py_INCREF(Py_None); resultobj = Py_None;
38209 return resultobj;
38210 fail:
38211 return NULL;
38212 }
38213
38214
38215 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj = NULL;
38217 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38218 PyObject * obj0 = 0 ;
38219 char *kwnames[] = {
38220 (char *) "self", NULL
38221 };
38222
38223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38225 if (SWIG_arg_fail(1)) SWIG_fail;
38226 {
38227 PyThreadState* __tstate = wxPyBeginAllowThreads();
38228 (arg1)->ResetOwnerDrawn();
38229
38230 wxPyEndAllowThreads(__tstate);
38231 if (PyErr_Occurred()) SWIG_fail;
38232 }
38233 Py_INCREF(Py_None); resultobj = Py_None;
38234 return resultobj;
38235 fail:
38236 return NULL;
38237 }
38238
38239
38240 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38241 PyObject *obj;
38242 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38243 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38244 Py_INCREF(obj);
38245 return Py_BuildValue((char *)"");
38246 }
38247 static int _wrap_ControlNameStr_set(PyObject *) {
38248 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38249 return 1;
38250 }
38251
38252
38253 static PyObject *_wrap_ControlNameStr_get(void) {
38254 PyObject *pyobj = NULL;
38255
38256 {
38257 #if wxUSE_UNICODE
38258 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38259 #else
38260 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38261 #endif
38262 }
38263 return pyobj;
38264 }
38265
38266
38267 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38268 PyObject *resultobj = NULL;
38269 wxWindow *arg1 = (wxWindow *) 0 ;
38270 int arg2 = (int) -1 ;
38271 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38272 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38273 wxSize const &arg4_defvalue = wxDefaultSize ;
38274 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38275 long arg5 = (long) 0 ;
38276 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38277 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38278 wxString const &arg7_defvalue = wxPyControlNameStr ;
38279 wxString *arg7 = (wxString *) &arg7_defvalue ;
38280 wxControl *result;
38281 wxPoint temp3 ;
38282 wxSize temp4 ;
38283 bool temp7 = false ;
38284 PyObject * obj0 = 0 ;
38285 PyObject * obj1 = 0 ;
38286 PyObject * obj2 = 0 ;
38287 PyObject * obj3 = 0 ;
38288 PyObject * obj4 = 0 ;
38289 PyObject * obj5 = 0 ;
38290 PyObject * obj6 = 0 ;
38291 char *kwnames[] = {
38292 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38293 };
38294
38295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38297 if (SWIG_arg_fail(1)) SWIG_fail;
38298 if (obj1) {
38299 {
38300 arg2 = static_cast<int >(SWIG_As_int(obj1));
38301 if (SWIG_arg_fail(2)) SWIG_fail;
38302 }
38303 }
38304 if (obj2) {
38305 {
38306 arg3 = &temp3;
38307 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38308 }
38309 }
38310 if (obj3) {
38311 {
38312 arg4 = &temp4;
38313 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38314 }
38315 }
38316 if (obj4) {
38317 {
38318 arg5 = static_cast<long >(SWIG_As_long(obj4));
38319 if (SWIG_arg_fail(5)) SWIG_fail;
38320 }
38321 }
38322 if (obj5) {
38323 {
38324 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38325 if (SWIG_arg_fail(6)) SWIG_fail;
38326 if (arg6 == NULL) {
38327 SWIG_null_ref("wxValidator");
38328 }
38329 if (SWIG_arg_fail(6)) SWIG_fail;
38330 }
38331 }
38332 if (obj6) {
38333 {
38334 arg7 = wxString_in_helper(obj6);
38335 if (arg7 == NULL) SWIG_fail;
38336 temp7 = true;
38337 }
38338 }
38339 {
38340 if (!wxPyCheckForApp()) SWIG_fail;
38341 PyThreadState* __tstate = wxPyBeginAllowThreads();
38342 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38343
38344 wxPyEndAllowThreads(__tstate);
38345 if (PyErr_Occurred()) SWIG_fail;
38346 }
38347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38348 {
38349 if (temp7)
38350 delete arg7;
38351 }
38352 return resultobj;
38353 fail:
38354 {
38355 if (temp7)
38356 delete arg7;
38357 }
38358 return NULL;
38359 }
38360
38361
38362 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38363 PyObject *resultobj = NULL;
38364 wxControl *result;
38365 char *kwnames[] = {
38366 NULL
38367 };
38368
38369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38370 {
38371 if (!wxPyCheckForApp()) SWIG_fail;
38372 PyThreadState* __tstate = wxPyBeginAllowThreads();
38373 result = (wxControl *)new wxControl();
38374
38375 wxPyEndAllowThreads(__tstate);
38376 if (PyErr_Occurred()) SWIG_fail;
38377 }
38378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38379 return resultobj;
38380 fail:
38381 return NULL;
38382 }
38383
38384
38385 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38386 PyObject *resultobj = NULL;
38387 wxControl *arg1 = (wxControl *) 0 ;
38388 wxWindow *arg2 = (wxWindow *) 0 ;
38389 int arg3 = (int) -1 ;
38390 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38391 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38392 wxSize const &arg5_defvalue = wxDefaultSize ;
38393 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38394 long arg6 = (long) 0 ;
38395 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38396 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38397 wxString const &arg8_defvalue = wxPyControlNameStr ;
38398 wxString *arg8 = (wxString *) &arg8_defvalue ;
38399 bool result;
38400 wxPoint temp4 ;
38401 wxSize temp5 ;
38402 bool temp8 = false ;
38403 PyObject * obj0 = 0 ;
38404 PyObject * obj1 = 0 ;
38405 PyObject * obj2 = 0 ;
38406 PyObject * obj3 = 0 ;
38407 PyObject * obj4 = 0 ;
38408 PyObject * obj5 = 0 ;
38409 PyObject * obj6 = 0 ;
38410 PyObject * obj7 = 0 ;
38411 char *kwnames[] = {
38412 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38413 };
38414
38415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38417 if (SWIG_arg_fail(1)) SWIG_fail;
38418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38419 if (SWIG_arg_fail(2)) SWIG_fail;
38420 if (obj2) {
38421 {
38422 arg3 = static_cast<int >(SWIG_As_int(obj2));
38423 if (SWIG_arg_fail(3)) SWIG_fail;
38424 }
38425 }
38426 if (obj3) {
38427 {
38428 arg4 = &temp4;
38429 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38430 }
38431 }
38432 if (obj4) {
38433 {
38434 arg5 = &temp5;
38435 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38436 }
38437 }
38438 if (obj5) {
38439 {
38440 arg6 = static_cast<long >(SWIG_As_long(obj5));
38441 if (SWIG_arg_fail(6)) SWIG_fail;
38442 }
38443 }
38444 if (obj6) {
38445 {
38446 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38447 if (SWIG_arg_fail(7)) SWIG_fail;
38448 if (arg7 == NULL) {
38449 SWIG_null_ref("wxValidator");
38450 }
38451 if (SWIG_arg_fail(7)) SWIG_fail;
38452 }
38453 }
38454 if (obj7) {
38455 {
38456 arg8 = wxString_in_helper(obj7);
38457 if (arg8 == NULL) SWIG_fail;
38458 temp8 = true;
38459 }
38460 }
38461 {
38462 PyThreadState* __tstate = wxPyBeginAllowThreads();
38463 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38464
38465 wxPyEndAllowThreads(__tstate);
38466 if (PyErr_Occurred()) SWIG_fail;
38467 }
38468 {
38469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38470 }
38471 {
38472 if (temp8)
38473 delete arg8;
38474 }
38475 return resultobj;
38476 fail:
38477 {
38478 if (temp8)
38479 delete arg8;
38480 }
38481 return NULL;
38482 }
38483
38484
38485 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38486 PyObject *resultobj = NULL;
38487 wxControl *arg1 = (wxControl *) 0 ;
38488 wxCommandEvent *arg2 = 0 ;
38489 PyObject * obj0 = 0 ;
38490 PyObject * obj1 = 0 ;
38491 char *kwnames[] = {
38492 (char *) "self",(char *) "event", NULL
38493 };
38494
38495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38497 if (SWIG_arg_fail(1)) SWIG_fail;
38498 {
38499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38500 if (SWIG_arg_fail(2)) SWIG_fail;
38501 if (arg2 == NULL) {
38502 SWIG_null_ref("wxCommandEvent");
38503 }
38504 if (SWIG_arg_fail(2)) SWIG_fail;
38505 }
38506 {
38507 PyThreadState* __tstate = wxPyBeginAllowThreads();
38508 (arg1)->Command(*arg2);
38509
38510 wxPyEndAllowThreads(__tstate);
38511 if (PyErr_Occurred()) SWIG_fail;
38512 }
38513 Py_INCREF(Py_None); resultobj = Py_None;
38514 return resultobj;
38515 fail:
38516 return NULL;
38517 }
38518
38519
38520 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38521 PyObject *resultobj = NULL;
38522 wxControl *arg1 = (wxControl *) 0 ;
38523 wxString result;
38524 PyObject * obj0 = 0 ;
38525 char *kwnames[] = {
38526 (char *) "self", NULL
38527 };
38528
38529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38531 if (SWIG_arg_fail(1)) SWIG_fail;
38532 {
38533 PyThreadState* __tstate = wxPyBeginAllowThreads();
38534 result = (arg1)->GetLabel();
38535
38536 wxPyEndAllowThreads(__tstate);
38537 if (PyErr_Occurred()) SWIG_fail;
38538 }
38539 {
38540 #if wxUSE_UNICODE
38541 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38542 #else
38543 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38544 #endif
38545 }
38546 return resultobj;
38547 fail:
38548 return NULL;
38549 }
38550
38551
38552 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38553 PyObject *resultobj = NULL;
38554 wxControl *arg1 = (wxControl *) 0 ;
38555 wxString *arg2 = 0 ;
38556 bool temp2 = false ;
38557 PyObject * obj0 = 0 ;
38558 PyObject * obj1 = 0 ;
38559 char *kwnames[] = {
38560 (char *) "self",(char *) "label", NULL
38561 };
38562
38563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38565 if (SWIG_arg_fail(1)) SWIG_fail;
38566 {
38567 arg2 = wxString_in_helper(obj1);
38568 if (arg2 == NULL) SWIG_fail;
38569 temp2 = true;
38570 }
38571 {
38572 PyThreadState* __tstate = wxPyBeginAllowThreads();
38573 (arg1)->SetLabel((wxString const &)*arg2);
38574
38575 wxPyEndAllowThreads(__tstate);
38576 if (PyErr_Occurred()) SWIG_fail;
38577 }
38578 Py_INCREF(Py_None); resultobj = Py_None;
38579 {
38580 if (temp2)
38581 delete arg2;
38582 }
38583 return resultobj;
38584 fail:
38585 {
38586 if (temp2)
38587 delete arg2;
38588 }
38589 return NULL;
38590 }
38591
38592
38593 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38594 PyObject *resultobj = NULL;
38595 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38596 wxVisualAttributes result;
38597 PyObject * obj0 = 0 ;
38598 char *kwnames[] = {
38599 (char *) "variant", NULL
38600 };
38601
38602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38603 if (obj0) {
38604 {
38605 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38606 if (SWIG_arg_fail(1)) SWIG_fail;
38607 }
38608 }
38609 {
38610 if (!wxPyCheckForApp()) SWIG_fail;
38611 PyThreadState* __tstate = wxPyBeginAllowThreads();
38612 result = wxControl::GetClassDefaultAttributes(arg1);
38613
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 {
38618 wxVisualAttributes * resultptr;
38619 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38621 }
38622 return resultobj;
38623 fail:
38624 return NULL;
38625 }
38626
38627
38628 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38629 PyObject *obj;
38630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38631 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38632 Py_INCREF(obj);
38633 return Py_BuildValue((char *)"");
38634 }
38635 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38636 PyObject *resultobj = NULL;
38637 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38638 wxString *arg2 = 0 ;
38639 PyObject *arg3 = (PyObject *) NULL ;
38640 int result;
38641 bool temp2 = false ;
38642 PyObject * obj0 = 0 ;
38643 PyObject * obj1 = 0 ;
38644 PyObject * obj2 = 0 ;
38645 char *kwnames[] = {
38646 (char *) "self",(char *) "item",(char *) "clientData", NULL
38647 };
38648
38649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38651 if (SWIG_arg_fail(1)) SWIG_fail;
38652 {
38653 arg2 = wxString_in_helper(obj1);
38654 if (arg2 == NULL) SWIG_fail;
38655 temp2 = true;
38656 }
38657 if (obj2) {
38658 arg3 = obj2;
38659 }
38660 {
38661 PyThreadState* __tstate = wxPyBeginAllowThreads();
38662 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38663
38664 wxPyEndAllowThreads(__tstate);
38665 if (PyErr_Occurred()) SWIG_fail;
38666 }
38667 {
38668 resultobj = SWIG_From_int(static_cast<int >(result));
38669 }
38670 {
38671 if (temp2)
38672 delete arg2;
38673 }
38674 return resultobj;
38675 fail:
38676 {
38677 if (temp2)
38678 delete arg2;
38679 }
38680 return NULL;
38681 }
38682
38683
38684 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38685 PyObject *resultobj = NULL;
38686 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38687 wxArrayString *arg2 = 0 ;
38688 bool temp2 = false ;
38689 PyObject * obj0 = 0 ;
38690 PyObject * obj1 = 0 ;
38691 char *kwnames[] = {
38692 (char *) "self",(char *) "strings", NULL
38693 };
38694
38695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38697 if (SWIG_arg_fail(1)) SWIG_fail;
38698 {
38699 if (! PySequence_Check(obj1)) {
38700 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38701 SWIG_fail;
38702 }
38703 arg2 = new wxArrayString;
38704 temp2 = true;
38705 int i, len=PySequence_Length(obj1);
38706 for (i=0; i<len; i++) {
38707 PyObject* item = PySequence_GetItem(obj1, i);
38708 wxString* s = wxString_in_helper(item);
38709 if (PyErr_Occurred()) SWIG_fail;
38710 arg2->Add(*s);
38711 delete s;
38712 Py_DECREF(item);
38713 }
38714 }
38715 {
38716 PyThreadState* __tstate = wxPyBeginAllowThreads();
38717 (arg1)->Append((wxArrayString const &)*arg2);
38718
38719 wxPyEndAllowThreads(__tstate);
38720 if (PyErr_Occurred()) SWIG_fail;
38721 }
38722 Py_INCREF(Py_None); resultobj = Py_None;
38723 {
38724 if (temp2) delete arg2;
38725 }
38726 return resultobj;
38727 fail:
38728 {
38729 if (temp2) delete arg2;
38730 }
38731 return NULL;
38732 }
38733
38734
38735 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38736 PyObject *resultobj = NULL;
38737 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38738 wxString *arg2 = 0 ;
38739 int arg3 ;
38740 PyObject *arg4 = (PyObject *) NULL ;
38741 int result;
38742 bool temp2 = false ;
38743 PyObject * obj0 = 0 ;
38744 PyObject * obj1 = 0 ;
38745 PyObject * obj2 = 0 ;
38746 PyObject * obj3 = 0 ;
38747 char *kwnames[] = {
38748 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38749 };
38750
38751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38753 if (SWIG_arg_fail(1)) SWIG_fail;
38754 {
38755 arg2 = wxString_in_helper(obj1);
38756 if (arg2 == NULL) SWIG_fail;
38757 temp2 = true;
38758 }
38759 {
38760 arg3 = static_cast<int >(SWIG_As_int(obj2));
38761 if (SWIG_arg_fail(3)) SWIG_fail;
38762 }
38763 if (obj3) {
38764 arg4 = obj3;
38765 }
38766 {
38767 PyThreadState* __tstate = wxPyBeginAllowThreads();
38768 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38769
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 {
38774 resultobj = SWIG_From_int(static_cast<int >(result));
38775 }
38776 {
38777 if (temp2)
38778 delete arg2;
38779 }
38780 return resultobj;
38781 fail:
38782 {
38783 if (temp2)
38784 delete arg2;
38785 }
38786 return NULL;
38787 }
38788
38789
38790 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38791 PyObject *resultobj = NULL;
38792 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38793 PyObject * obj0 = 0 ;
38794 char *kwnames[] = {
38795 (char *) "self", NULL
38796 };
38797
38798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38800 if (SWIG_arg_fail(1)) SWIG_fail;
38801 {
38802 PyThreadState* __tstate = wxPyBeginAllowThreads();
38803 (arg1)->Clear();
38804
38805 wxPyEndAllowThreads(__tstate);
38806 if (PyErr_Occurred()) SWIG_fail;
38807 }
38808 Py_INCREF(Py_None); resultobj = Py_None;
38809 return resultobj;
38810 fail:
38811 return NULL;
38812 }
38813
38814
38815 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38816 PyObject *resultobj = NULL;
38817 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38818 int arg2 ;
38819 PyObject * obj0 = 0 ;
38820 PyObject * obj1 = 0 ;
38821 char *kwnames[] = {
38822 (char *) "self",(char *) "n", NULL
38823 };
38824
38825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38827 if (SWIG_arg_fail(1)) SWIG_fail;
38828 {
38829 arg2 = static_cast<int >(SWIG_As_int(obj1));
38830 if (SWIG_arg_fail(2)) SWIG_fail;
38831 }
38832 {
38833 PyThreadState* __tstate = wxPyBeginAllowThreads();
38834 (arg1)->Delete(arg2);
38835
38836 wxPyEndAllowThreads(__tstate);
38837 if (PyErr_Occurred()) SWIG_fail;
38838 }
38839 Py_INCREF(Py_None); resultobj = Py_None;
38840 return resultobj;
38841 fail:
38842 return NULL;
38843 }
38844
38845
38846 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38847 PyObject *resultobj = NULL;
38848 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38849 int arg2 ;
38850 PyObject *result;
38851 PyObject * obj0 = 0 ;
38852 PyObject * obj1 = 0 ;
38853 char *kwnames[] = {
38854 (char *) "self",(char *) "n", NULL
38855 };
38856
38857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38859 if (SWIG_arg_fail(1)) SWIG_fail;
38860 {
38861 arg2 = static_cast<int >(SWIG_As_int(obj1));
38862 if (SWIG_arg_fail(2)) SWIG_fail;
38863 }
38864 {
38865 PyThreadState* __tstate = wxPyBeginAllowThreads();
38866 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38867
38868 wxPyEndAllowThreads(__tstate);
38869 if (PyErr_Occurred()) SWIG_fail;
38870 }
38871 resultobj = result;
38872 return resultobj;
38873 fail:
38874 return NULL;
38875 }
38876
38877
38878 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38879 PyObject *resultobj = NULL;
38880 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38881 int arg2 ;
38882 PyObject *arg3 = (PyObject *) 0 ;
38883 PyObject * obj0 = 0 ;
38884 PyObject * obj1 = 0 ;
38885 PyObject * obj2 = 0 ;
38886 char *kwnames[] = {
38887 (char *) "self",(char *) "n",(char *) "clientData", NULL
38888 };
38889
38890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38892 if (SWIG_arg_fail(1)) SWIG_fail;
38893 {
38894 arg2 = static_cast<int >(SWIG_As_int(obj1));
38895 if (SWIG_arg_fail(2)) SWIG_fail;
38896 }
38897 arg3 = obj2;
38898 {
38899 PyThreadState* __tstate = wxPyBeginAllowThreads();
38900 wxItemContainer_SetClientData(arg1,arg2,arg3);
38901
38902 wxPyEndAllowThreads(__tstate);
38903 if (PyErr_Occurred()) SWIG_fail;
38904 }
38905 Py_INCREF(Py_None); resultobj = Py_None;
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38913 PyObject *resultobj = NULL;
38914 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38915 int result;
38916 PyObject * obj0 = 0 ;
38917 char *kwnames[] = {
38918 (char *) "self", NULL
38919 };
38920
38921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38923 if (SWIG_arg_fail(1)) SWIG_fail;
38924 {
38925 PyThreadState* __tstate = wxPyBeginAllowThreads();
38926 result = (int)((wxItemContainer const *)arg1)->GetCount();
38927
38928 wxPyEndAllowThreads(__tstate);
38929 if (PyErr_Occurred()) SWIG_fail;
38930 }
38931 {
38932 resultobj = SWIG_From_int(static_cast<int >(result));
38933 }
38934 return resultobj;
38935 fail:
38936 return NULL;
38937 }
38938
38939
38940 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38941 PyObject *resultobj = NULL;
38942 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38943 bool result;
38944 PyObject * obj0 = 0 ;
38945 char *kwnames[] = {
38946 (char *) "self", NULL
38947 };
38948
38949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38951 if (SWIG_arg_fail(1)) SWIG_fail;
38952 {
38953 PyThreadState* __tstate = wxPyBeginAllowThreads();
38954 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38955
38956 wxPyEndAllowThreads(__tstate);
38957 if (PyErr_Occurred()) SWIG_fail;
38958 }
38959 {
38960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38961 }
38962 return resultobj;
38963 fail:
38964 return NULL;
38965 }
38966
38967
38968 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38969 PyObject *resultobj = NULL;
38970 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38971 int arg2 ;
38972 wxString result;
38973 PyObject * obj0 = 0 ;
38974 PyObject * obj1 = 0 ;
38975 char *kwnames[] = {
38976 (char *) "self",(char *) "n", NULL
38977 };
38978
38979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38981 if (SWIG_arg_fail(1)) SWIG_fail;
38982 {
38983 arg2 = static_cast<int >(SWIG_As_int(obj1));
38984 if (SWIG_arg_fail(2)) SWIG_fail;
38985 }
38986 {
38987 PyThreadState* __tstate = wxPyBeginAllowThreads();
38988 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38989
38990 wxPyEndAllowThreads(__tstate);
38991 if (PyErr_Occurred()) SWIG_fail;
38992 }
38993 {
38994 #if wxUSE_UNICODE
38995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38996 #else
38997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38998 #endif
38999 }
39000 return resultobj;
39001 fail:
39002 return NULL;
39003 }
39004
39005
39006 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
39007 PyObject *resultobj = NULL;
39008 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39009 wxArrayString result;
39010 PyObject * obj0 = 0 ;
39011 char *kwnames[] = {
39012 (char *) "self", NULL
39013 };
39014
39015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
39016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39017 if (SWIG_arg_fail(1)) SWIG_fail;
39018 {
39019 PyThreadState* __tstate = wxPyBeginAllowThreads();
39020 result = ((wxItemContainer const *)arg1)->GetStrings();
39021
39022 wxPyEndAllowThreads(__tstate);
39023 if (PyErr_Occurred()) SWIG_fail;
39024 }
39025 {
39026 resultobj = wxArrayString2PyList_helper(result);
39027 }
39028 return resultobj;
39029 fail:
39030 return NULL;
39031 }
39032
39033
39034 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
39035 PyObject *resultobj = NULL;
39036 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39037 int arg2 ;
39038 wxString *arg3 = 0 ;
39039 bool temp3 = false ;
39040 PyObject * obj0 = 0 ;
39041 PyObject * obj1 = 0 ;
39042 PyObject * obj2 = 0 ;
39043 char *kwnames[] = {
39044 (char *) "self",(char *) "n",(char *) "s", NULL
39045 };
39046
39047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
39048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39049 if (SWIG_arg_fail(1)) SWIG_fail;
39050 {
39051 arg2 = static_cast<int >(SWIG_As_int(obj1));
39052 if (SWIG_arg_fail(2)) SWIG_fail;
39053 }
39054 {
39055 arg3 = wxString_in_helper(obj2);
39056 if (arg3 == NULL) SWIG_fail;
39057 temp3 = true;
39058 }
39059 {
39060 PyThreadState* __tstate = wxPyBeginAllowThreads();
39061 (arg1)->SetString(arg2,(wxString const &)*arg3);
39062
39063 wxPyEndAllowThreads(__tstate);
39064 if (PyErr_Occurred()) SWIG_fail;
39065 }
39066 Py_INCREF(Py_None); resultobj = Py_None;
39067 {
39068 if (temp3)
39069 delete arg3;
39070 }
39071 return resultobj;
39072 fail:
39073 {
39074 if (temp3)
39075 delete arg3;
39076 }
39077 return NULL;
39078 }
39079
39080
39081 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39082 PyObject *resultobj = NULL;
39083 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39084 wxString *arg2 = 0 ;
39085 int result;
39086 bool temp2 = false ;
39087 PyObject * obj0 = 0 ;
39088 PyObject * obj1 = 0 ;
39089 char *kwnames[] = {
39090 (char *) "self",(char *) "s", NULL
39091 };
39092
39093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39095 if (SWIG_arg_fail(1)) SWIG_fail;
39096 {
39097 arg2 = wxString_in_helper(obj1);
39098 if (arg2 == NULL) SWIG_fail;
39099 temp2 = true;
39100 }
39101 {
39102 PyThreadState* __tstate = wxPyBeginAllowThreads();
39103 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39104
39105 wxPyEndAllowThreads(__tstate);
39106 if (PyErr_Occurred()) SWIG_fail;
39107 }
39108 {
39109 resultobj = SWIG_From_int(static_cast<int >(result));
39110 }
39111 {
39112 if (temp2)
39113 delete arg2;
39114 }
39115 return resultobj;
39116 fail:
39117 {
39118 if (temp2)
39119 delete arg2;
39120 }
39121 return NULL;
39122 }
39123
39124
39125 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39126 PyObject *resultobj = NULL;
39127 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39128 int arg2 ;
39129 PyObject * obj0 = 0 ;
39130 PyObject * obj1 = 0 ;
39131 char *kwnames[] = {
39132 (char *) "self",(char *) "n", NULL
39133 };
39134
39135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39137 if (SWIG_arg_fail(1)) SWIG_fail;
39138 {
39139 arg2 = static_cast<int >(SWIG_As_int(obj1));
39140 if (SWIG_arg_fail(2)) SWIG_fail;
39141 }
39142 {
39143 PyThreadState* __tstate = wxPyBeginAllowThreads();
39144 (arg1)->SetSelection(arg2);
39145
39146 wxPyEndAllowThreads(__tstate);
39147 if (PyErr_Occurred()) SWIG_fail;
39148 }
39149 Py_INCREF(Py_None); resultobj = Py_None;
39150 return resultobj;
39151 fail:
39152 return NULL;
39153 }
39154
39155
39156 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39157 PyObject *resultobj = NULL;
39158 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39159 int result;
39160 PyObject * obj0 = 0 ;
39161 char *kwnames[] = {
39162 (char *) "self", NULL
39163 };
39164
39165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39167 if (SWIG_arg_fail(1)) SWIG_fail;
39168 {
39169 PyThreadState* __tstate = wxPyBeginAllowThreads();
39170 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39171
39172 wxPyEndAllowThreads(__tstate);
39173 if (PyErr_Occurred()) SWIG_fail;
39174 }
39175 {
39176 resultobj = SWIG_From_int(static_cast<int >(result));
39177 }
39178 return resultobj;
39179 fail:
39180 return NULL;
39181 }
39182
39183
39184 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39185 PyObject *resultobj = NULL;
39186 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39187 wxString *arg2 = 0 ;
39188 bool result;
39189 bool temp2 = false ;
39190 PyObject * obj0 = 0 ;
39191 PyObject * obj1 = 0 ;
39192 char *kwnames[] = {
39193 (char *) "self",(char *) "s", NULL
39194 };
39195
39196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",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 = wxString_in_helper(obj1);
39201 if (arg2 == NULL) SWIG_fail;
39202 temp2 = true;
39203 }
39204 {
39205 PyThreadState* __tstate = wxPyBeginAllowThreads();
39206 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39207
39208 wxPyEndAllowThreads(__tstate);
39209 if (PyErr_Occurred()) SWIG_fail;
39210 }
39211 {
39212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39213 }
39214 {
39215 if (temp2)
39216 delete arg2;
39217 }
39218 return resultobj;
39219 fail:
39220 {
39221 if (temp2)
39222 delete arg2;
39223 }
39224 return NULL;
39225 }
39226
39227
39228 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39229 PyObject *resultobj = NULL;
39230 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39231 wxString result;
39232 PyObject * obj0 = 0 ;
39233 char *kwnames[] = {
39234 (char *) "self", NULL
39235 };
39236
39237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39239 if (SWIG_arg_fail(1)) SWIG_fail;
39240 {
39241 PyThreadState* __tstate = wxPyBeginAllowThreads();
39242 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39243
39244 wxPyEndAllowThreads(__tstate);
39245 if (PyErr_Occurred()) SWIG_fail;
39246 }
39247 {
39248 #if wxUSE_UNICODE
39249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39250 #else
39251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39252 #endif
39253 }
39254 return resultobj;
39255 fail:
39256 return NULL;
39257 }
39258
39259
39260 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39261 PyObject *resultobj = NULL;
39262 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39263 int arg2 ;
39264 PyObject * obj0 = 0 ;
39265 PyObject * obj1 = 0 ;
39266 char *kwnames[] = {
39267 (char *) "self",(char *) "n", NULL
39268 };
39269
39270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39272 if (SWIG_arg_fail(1)) SWIG_fail;
39273 {
39274 arg2 = static_cast<int >(SWIG_As_int(obj1));
39275 if (SWIG_arg_fail(2)) SWIG_fail;
39276 }
39277 {
39278 PyThreadState* __tstate = wxPyBeginAllowThreads();
39279 (arg1)->Select(arg2);
39280
39281 wxPyEndAllowThreads(__tstate);
39282 if (PyErr_Occurred()) SWIG_fail;
39283 }
39284 Py_INCREF(Py_None); resultobj = Py_None;
39285 return resultobj;
39286 fail:
39287 return NULL;
39288 }
39289
39290
39291 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39292 PyObject *obj;
39293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39294 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39295 Py_INCREF(obj);
39296 return Py_BuildValue((char *)"");
39297 }
39298 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39299 PyObject *obj;
39300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39301 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39302 Py_INCREF(obj);
39303 return Py_BuildValue((char *)"");
39304 }
39305 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39306 PyObject *resultobj = NULL;
39307 wxSizerItem *result;
39308 char *kwnames[] = {
39309 NULL
39310 };
39311
39312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39313 {
39314 PyThreadState* __tstate = wxPyBeginAllowThreads();
39315 result = (wxSizerItem *)new wxSizerItem();
39316
39317 wxPyEndAllowThreads(__tstate);
39318 if (PyErr_Occurred()) SWIG_fail;
39319 }
39320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39321 return resultobj;
39322 fail:
39323 return NULL;
39324 }
39325
39326
39327 static PyObject *_wrap_delete_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39328 PyObject *resultobj = NULL;
39329 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39330 PyObject * obj0 = 0 ;
39331 char *kwnames[] = {
39332 (char *) "self", NULL
39333 };
39334
39335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SizerItem",kwnames,&obj0)) goto fail;
39336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39337 if (SWIG_arg_fail(1)) SWIG_fail;
39338 {
39339 PyThreadState* __tstate = wxPyBeginAllowThreads();
39340 delete arg1;
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 *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39353 PyObject *resultobj = NULL;
39354 wxWindow *arg1 = (wxWindow *) 0 ;
39355 int arg2 ;
39356 int arg3 ;
39357 int arg4 ;
39358 PyObject *arg5 = (PyObject *) NULL ;
39359 wxSizerItem *result;
39360 PyObject * obj0 = 0 ;
39361 PyObject * obj1 = 0 ;
39362 PyObject * obj2 = 0 ;
39363 PyObject * obj3 = 0 ;
39364 PyObject * obj4 = 0 ;
39365 char *kwnames[] = {
39366 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39367 };
39368
39369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39371 if (SWIG_arg_fail(1)) SWIG_fail;
39372 {
39373 arg2 = static_cast<int >(SWIG_As_int(obj1));
39374 if (SWIG_arg_fail(2)) SWIG_fail;
39375 }
39376 {
39377 arg3 = static_cast<int >(SWIG_As_int(obj2));
39378 if (SWIG_arg_fail(3)) SWIG_fail;
39379 }
39380 {
39381 arg4 = static_cast<int >(SWIG_As_int(obj3));
39382 if (SWIG_arg_fail(4)) SWIG_fail;
39383 }
39384 if (obj4) {
39385 arg5 = obj4;
39386 }
39387 {
39388 PyThreadState* __tstate = wxPyBeginAllowThreads();
39389 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39390
39391 wxPyEndAllowThreads(__tstate);
39392 if (PyErr_Occurred()) SWIG_fail;
39393 }
39394 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39395 return resultobj;
39396 fail:
39397 return NULL;
39398 }
39399
39400
39401 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39402 PyObject *resultobj = NULL;
39403 int arg1 ;
39404 int arg2 ;
39405 int arg3 ;
39406 int arg4 ;
39407 int arg5 ;
39408 PyObject *arg6 = (PyObject *) NULL ;
39409 wxSizerItem *result;
39410 PyObject * obj0 = 0 ;
39411 PyObject * obj1 = 0 ;
39412 PyObject * obj2 = 0 ;
39413 PyObject * obj3 = 0 ;
39414 PyObject * obj4 = 0 ;
39415 PyObject * obj5 = 0 ;
39416 char *kwnames[] = {
39417 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39418 };
39419
39420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39421 {
39422 arg1 = static_cast<int >(SWIG_As_int(obj0));
39423 if (SWIG_arg_fail(1)) SWIG_fail;
39424 }
39425 {
39426 arg2 = static_cast<int >(SWIG_As_int(obj1));
39427 if (SWIG_arg_fail(2)) SWIG_fail;
39428 }
39429 {
39430 arg3 = static_cast<int >(SWIG_As_int(obj2));
39431 if (SWIG_arg_fail(3)) SWIG_fail;
39432 }
39433 {
39434 arg4 = static_cast<int >(SWIG_As_int(obj3));
39435 if (SWIG_arg_fail(4)) SWIG_fail;
39436 }
39437 {
39438 arg5 = static_cast<int >(SWIG_As_int(obj4));
39439 if (SWIG_arg_fail(5)) SWIG_fail;
39440 }
39441 if (obj5) {
39442 arg6 = obj5;
39443 }
39444 {
39445 PyThreadState* __tstate = wxPyBeginAllowThreads();
39446 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39447
39448 wxPyEndAllowThreads(__tstate);
39449 if (PyErr_Occurred()) SWIG_fail;
39450 }
39451 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39452 return resultobj;
39453 fail:
39454 return NULL;
39455 }
39456
39457
39458 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39459 PyObject *resultobj = NULL;
39460 wxSizer *arg1 = (wxSizer *) 0 ;
39461 int arg2 ;
39462 int arg3 ;
39463 int arg4 ;
39464 PyObject *arg5 = (PyObject *) NULL ;
39465 wxSizerItem *result;
39466 PyObject * obj0 = 0 ;
39467 PyObject * obj1 = 0 ;
39468 PyObject * obj2 = 0 ;
39469 PyObject * obj3 = 0 ;
39470 PyObject * obj4 = 0 ;
39471 char *kwnames[] = {
39472 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39473 };
39474
39475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
39477 if (SWIG_arg_fail(1)) SWIG_fail;
39478 {
39479 arg2 = static_cast<int >(SWIG_As_int(obj1));
39480 if (SWIG_arg_fail(2)) SWIG_fail;
39481 }
39482 {
39483 arg3 = static_cast<int >(SWIG_As_int(obj2));
39484 if (SWIG_arg_fail(3)) SWIG_fail;
39485 }
39486 {
39487 arg4 = static_cast<int >(SWIG_As_int(obj3));
39488 if (SWIG_arg_fail(4)) SWIG_fail;
39489 }
39490 if (obj4) {
39491 arg5 = obj4;
39492 }
39493 {
39494 PyThreadState* __tstate = wxPyBeginAllowThreads();
39495 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39496
39497 wxPyEndAllowThreads(__tstate);
39498 if (PyErr_Occurred()) SWIG_fail;
39499 }
39500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39501 return resultobj;
39502 fail:
39503 return NULL;
39504 }
39505
39506
39507 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39508 PyObject *resultobj = NULL;
39509 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39510 PyObject * obj0 = 0 ;
39511 char *kwnames[] = {
39512 (char *) "self", NULL
39513 };
39514
39515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39517 if (SWIG_arg_fail(1)) SWIG_fail;
39518 {
39519 PyThreadState* __tstate = wxPyBeginAllowThreads();
39520 (arg1)->DeleteWindows();
39521
39522 wxPyEndAllowThreads(__tstate);
39523 if (PyErr_Occurred()) SWIG_fail;
39524 }
39525 Py_INCREF(Py_None); resultobj = Py_None;
39526 return resultobj;
39527 fail:
39528 return NULL;
39529 }
39530
39531
39532 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39533 PyObject *resultobj = NULL;
39534 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39535 PyObject * obj0 = 0 ;
39536 char *kwnames[] = {
39537 (char *) "self", NULL
39538 };
39539
39540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39542 if (SWIG_arg_fail(1)) SWIG_fail;
39543 {
39544 PyThreadState* __tstate = wxPyBeginAllowThreads();
39545 (arg1)->DetachSizer();
39546
39547 wxPyEndAllowThreads(__tstate);
39548 if (PyErr_Occurred()) SWIG_fail;
39549 }
39550 Py_INCREF(Py_None); resultobj = Py_None;
39551 return resultobj;
39552 fail:
39553 return NULL;
39554 }
39555
39556
39557 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39558 PyObject *resultobj = NULL;
39559 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39560 wxSize result;
39561 PyObject * obj0 = 0 ;
39562 char *kwnames[] = {
39563 (char *) "self", NULL
39564 };
39565
39566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39568 if (SWIG_arg_fail(1)) SWIG_fail;
39569 {
39570 PyThreadState* __tstate = wxPyBeginAllowThreads();
39571 result = (arg1)->GetSize();
39572
39573 wxPyEndAllowThreads(__tstate);
39574 if (PyErr_Occurred()) SWIG_fail;
39575 }
39576 {
39577 wxSize * resultptr;
39578 resultptr = new wxSize(static_cast<wxSize & >(result));
39579 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39580 }
39581 return resultobj;
39582 fail:
39583 return NULL;
39584 }
39585
39586
39587 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39588 PyObject *resultobj = NULL;
39589 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39590 wxSize result;
39591 PyObject * obj0 = 0 ;
39592 char *kwnames[] = {
39593 (char *) "self", NULL
39594 };
39595
39596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39598 if (SWIG_arg_fail(1)) SWIG_fail;
39599 {
39600 PyThreadState* __tstate = wxPyBeginAllowThreads();
39601 result = (arg1)->CalcMin();
39602
39603 wxPyEndAllowThreads(__tstate);
39604 if (PyErr_Occurred()) SWIG_fail;
39605 }
39606 {
39607 wxSize * resultptr;
39608 resultptr = new wxSize(static_cast<wxSize & >(result));
39609 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39610 }
39611 return resultobj;
39612 fail:
39613 return NULL;
39614 }
39615
39616
39617 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39618 PyObject *resultobj = NULL;
39619 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39620 wxPoint *arg2 = 0 ;
39621 wxSize *arg3 = 0 ;
39622 wxPoint temp2 ;
39623 wxSize temp3 ;
39624 PyObject * obj0 = 0 ;
39625 PyObject * obj1 = 0 ;
39626 PyObject * obj2 = 0 ;
39627 char *kwnames[] = {
39628 (char *) "self",(char *) "pos",(char *) "size", NULL
39629 };
39630
39631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39633 if (SWIG_arg_fail(1)) SWIG_fail;
39634 {
39635 arg2 = &temp2;
39636 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39637 }
39638 {
39639 arg3 = &temp3;
39640 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39641 }
39642 {
39643 PyThreadState* __tstate = wxPyBeginAllowThreads();
39644 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
39645
39646 wxPyEndAllowThreads(__tstate);
39647 if (PyErr_Occurred()) SWIG_fail;
39648 }
39649 Py_INCREF(Py_None); resultobj = Py_None;
39650 return resultobj;
39651 fail:
39652 return NULL;
39653 }
39654
39655
39656 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39657 PyObject *resultobj = NULL;
39658 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39659 wxSize result;
39660 PyObject * obj0 = 0 ;
39661 char *kwnames[] = {
39662 (char *) "self", NULL
39663 };
39664
39665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39667 if (SWIG_arg_fail(1)) SWIG_fail;
39668 {
39669 PyThreadState* __tstate = wxPyBeginAllowThreads();
39670 result = (arg1)->GetMinSize();
39671
39672 wxPyEndAllowThreads(__tstate);
39673 if (PyErr_Occurred()) SWIG_fail;
39674 }
39675 {
39676 wxSize * resultptr;
39677 resultptr = new wxSize(static_cast<wxSize & >(result));
39678 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39679 }
39680 return resultobj;
39681 fail:
39682 return NULL;
39683 }
39684
39685
39686 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39687 PyObject *resultobj = NULL;
39688 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39689 wxSize result;
39690 PyObject * obj0 = 0 ;
39691 char *kwnames[] = {
39692 (char *) "self", NULL
39693 };
39694
39695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39697 if (SWIG_arg_fail(1)) SWIG_fail;
39698 {
39699 PyThreadState* __tstate = wxPyBeginAllowThreads();
39700 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39701
39702 wxPyEndAllowThreads(__tstate);
39703 if (PyErr_Occurred()) SWIG_fail;
39704 }
39705 {
39706 wxSize * resultptr;
39707 resultptr = new wxSize(static_cast<wxSize & >(result));
39708 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39709 }
39710 return resultobj;
39711 fail:
39712 return NULL;
39713 }
39714
39715
39716 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39717 PyObject *resultobj = NULL;
39718 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39719 int arg2 ;
39720 int arg3 ;
39721 PyObject * obj0 = 0 ;
39722 PyObject * obj1 = 0 ;
39723 PyObject * obj2 = 0 ;
39724 char *kwnames[] = {
39725 (char *) "self",(char *) "x",(char *) "y", NULL
39726 };
39727
39728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39730 if (SWIG_arg_fail(1)) SWIG_fail;
39731 {
39732 arg2 = static_cast<int >(SWIG_As_int(obj1));
39733 if (SWIG_arg_fail(2)) SWIG_fail;
39734 }
39735 {
39736 arg3 = static_cast<int >(SWIG_As_int(obj2));
39737 if (SWIG_arg_fail(3)) SWIG_fail;
39738 }
39739 {
39740 PyThreadState* __tstate = wxPyBeginAllowThreads();
39741 (arg1)->SetInitSize(arg2,arg3);
39742
39743 wxPyEndAllowThreads(__tstate);
39744 if (PyErr_Occurred()) SWIG_fail;
39745 }
39746 Py_INCREF(Py_None); resultobj = Py_None;
39747 return resultobj;
39748 fail:
39749 return NULL;
39750 }
39751
39752
39753 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39754 PyObject *resultobj = NULL;
39755 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39756 int arg2 ;
39757 int arg3 ;
39758 PyObject * obj0 = 0 ;
39759 PyObject * obj1 = 0 ;
39760 PyObject * obj2 = 0 ;
39761 char *kwnames[] = {
39762 (char *) "self",(char *) "width",(char *) "height", NULL
39763 };
39764
39765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39767 if (SWIG_arg_fail(1)) SWIG_fail;
39768 {
39769 arg2 = static_cast<int >(SWIG_As_int(obj1));
39770 if (SWIG_arg_fail(2)) SWIG_fail;
39771 }
39772 {
39773 arg3 = static_cast<int >(SWIG_As_int(obj2));
39774 if (SWIG_arg_fail(3)) SWIG_fail;
39775 }
39776 {
39777 PyThreadState* __tstate = wxPyBeginAllowThreads();
39778 (arg1)->SetRatio(arg2,arg3);
39779
39780 wxPyEndAllowThreads(__tstate);
39781 if (PyErr_Occurred()) SWIG_fail;
39782 }
39783 Py_INCREF(Py_None); resultobj = Py_None;
39784 return resultobj;
39785 fail:
39786 return NULL;
39787 }
39788
39789
39790 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39791 PyObject *resultobj = NULL;
39792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39793 wxSize *arg2 = 0 ;
39794 wxSize temp2 ;
39795 PyObject * obj0 = 0 ;
39796 PyObject * obj1 = 0 ;
39797 char *kwnames[] = {
39798 (char *) "self",(char *) "size", NULL
39799 };
39800
39801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39803 if (SWIG_arg_fail(1)) SWIG_fail;
39804 {
39805 arg2 = &temp2;
39806 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39807 }
39808 {
39809 PyThreadState* __tstate = wxPyBeginAllowThreads();
39810 (arg1)->SetRatio((wxSize const &)*arg2);
39811
39812 wxPyEndAllowThreads(__tstate);
39813 if (PyErr_Occurred()) SWIG_fail;
39814 }
39815 Py_INCREF(Py_None); resultobj = Py_None;
39816 return resultobj;
39817 fail:
39818 return NULL;
39819 }
39820
39821
39822 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39823 PyObject *resultobj = NULL;
39824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39825 float arg2 ;
39826 PyObject * obj0 = 0 ;
39827 PyObject * obj1 = 0 ;
39828 char *kwnames[] = {
39829 (char *) "self",(char *) "ratio", NULL
39830 };
39831
39832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39834 if (SWIG_arg_fail(1)) SWIG_fail;
39835 {
39836 arg2 = static_cast<float >(SWIG_As_float(obj1));
39837 if (SWIG_arg_fail(2)) SWIG_fail;
39838 }
39839 {
39840 PyThreadState* __tstate = wxPyBeginAllowThreads();
39841 (arg1)->SetRatio(arg2);
39842
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 Py_INCREF(Py_None); resultobj = Py_None;
39847 return resultobj;
39848 fail:
39849 return NULL;
39850 }
39851
39852
39853 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39854 PyObject *resultobj = NULL;
39855 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39856 float result;
39857 PyObject * obj0 = 0 ;
39858 char *kwnames[] = {
39859 (char *) "self", NULL
39860 };
39861
39862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39864 if (SWIG_arg_fail(1)) SWIG_fail;
39865 {
39866 PyThreadState* __tstate = wxPyBeginAllowThreads();
39867 result = (float)(arg1)->GetRatio();
39868
39869 wxPyEndAllowThreads(__tstate);
39870 if (PyErr_Occurred()) SWIG_fail;
39871 }
39872 {
39873 resultobj = SWIG_From_float(static_cast<float >(result));
39874 }
39875 return resultobj;
39876 fail:
39877 return NULL;
39878 }
39879
39880
39881 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39882 PyObject *resultobj = NULL;
39883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39884 wxRect result;
39885 PyObject * obj0 = 0 ;
39886 char *kwnames[] = {
39887 (char *) "self", NULL
39888 };
39889
39890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39892 if (SWIG_arg_fail(1)) SWIG_fail;
39893 {
39894 PyThreadState* __tstate = wxPyBeginAllowThreads();
39895 result = (arg1)->GetRect();
39896
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 {
39901 wxRect * resultptr;
39902 resultptr = new wxRect(static_cast<wxRect & >(result));
39903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39904 }
39905 return resultobj;
39906 fail:
39907 return NULL;
39908 }
39909
39910
39911 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39912 PyObject *resultobj = NULL;
39913 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39914 bool result;
39915 PyObject * obj0 = 0 ;
39916 char *kwnames[] = {
39917 (char *) "self", NULL
39918 };
39919
39920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39922 if (SWIG_arg_fail(1)) SWIG_fail;
39923 {
39924 PyThreadState* __tstate = wxPyBeginAllowThreads();
39925 result = (bool)(arg1)->IsWindow();
39926
39927 wxPyEndAllowThreads(__tstate);
39928 if (PyErr_Occurred()) SWIG_fail;
39929 }
39930 {
39931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39932 }
39933 return resultobj;
39934 fail:
39935 return NULL;
39936 }
39937
39938
39939 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39940 PyObject *resultobj = NULL;
39941 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39942 bool result;
39943 PyObject * obj0 = 0 ;
39944 char *kwnames[] = {
39945 (char *) "self", NULL
39946 };
39947
39948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39950 if (SWIG_arg_fail(1)) SWIG_fail;
39951 {
39952 PyThreadState* __tstate = wxPyBeginAllowThreads();
39953 result = (bool)(arg1)->IsSizer();
39954
39955 wxPyEndAllowThreads(__tstate);
39956 if (PyErr_Occurred()) SWIG_fail;
39957 }
39958 {
39959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39960 }
39961 return resultobj;
39962 fail:
39963 return NULL;
39964 }
39965
39966
39967 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39968 PyObject *resultobj = NULL;
39969 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39970 bool result;
39971 PyObject * obj0 = 0 ;
39972 char *kwnames[] = {
39973 (char *) "self", NULL
39974 };
39975
39976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39978 if (SWIG_arg_fail(1)) SWIG_fail;
39979 {
39980 PyThreadState* __tstate = wxPyBeginAllowThreads();
39981 result = (bool)(arg1)->IsSpacer();
39982
39983 wxPyEndAllowThreads(__tstate);
39984 if (PyErr_Occurred()) SWIG_fail;
39985 }
39986 {
39987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39988 }
39989 return resultobj;
39990 fail:
39991 return NULL;
39992 }
39993
39994
39995 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39996 PyObject *resultobj = NULL;
39997 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39998 int arg2 ;
39999 PyObject * obj0 = 0 ;
40000 PyObject * obj1 = 0 ;
40001 char *kwnames[] = {
40002 (char *) "self",(char *) "proportion", NULL
40003 };
40004
40005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
40006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40007 if (SWIG_arg_fail(1)) SWIG_fail;
40008 {
40009 arg2 = static_cast<int >(SWIG_As_int(obj1));
40010 if (SWIG_arg_fail(2)) SWIG_fail;
40011 }
40012 {
40013 PyThreadState* __tstate = wxPyBeginAllowThreads();
40014 (arg1)->SetProportion(arg2);
40015
40016 wxPyEndAllowThreads(__tstate);
40017 if (PyErr_Occurred()) SWIG_fail;
40018 }
40019 Py_INCREF(Py_None); resultobj = Py_None;
40020 return resultobj;
40021 fail:
40022 return NULL;
40023 }
40024
40025
40026 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
40027 PyObject *resultobj = NULL;
40028 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40029 int result;
40030 PyObject * obj0 = 0 ;
40031 char *kwnames[] = {
40032 (char *) "self", NULL
40033 };
40034
40035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
40036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40037 if (SWIG_arg_fail(1)) SWIG_fail;
40038 {
40039 PyThreadState* __tstate = wxPyBeginAllowThreads();
40040 result = (int)(arg1)->GetProportion();
40041
40042 wxPyEndAllowThreads(__tstate);
40043 if (PyErr_Occurred()) SWIG_fail;
40044 }
40045 {
40046 resultobj = SWIG_From_int(static_cast<int >(result));
40047 }
40048 return resultobj;
40049 fail:
40050 return NULL;
40051 }
40052
40053
40054 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40055 PyObject *resultobj = NULL;
40056 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40057 int arg2 ;
40058 PyObject * obj0 = 0 ;
40059 PyObject * obj1 = 0 ;
40060 char *kwnames[] = {
40061 (char *) "self",(char *) "flag", NULL
40062 };
40063
40064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
40065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40066 if (SWIG_arg_fail(1)) SWIG_fail;
40067 {
40068 arg2 = static_cast<int >(SWIG_As_int(obj1));
40069 if (SWIG_arg_fail(2)) SWIG_fail;
40070 }
40071 {
40072 PyThreadState* __tstate = wxPyBeginAllowThreads();
40073 (arg1)->SetFlag(arg2);
40074
40075 wxPyEndAllowThreads(__tstate);
40076 if (PyErr_Occurred()) SWIG_fail;
40077 }
40078 Py_INCREF(Py_None); resultobj = Py_None;
40079 return resultobj;
40080 fail:
40081 return NULL;
40082 }
40083
40084
40085 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40086 PyObject *resultobj = NULL;
40087 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40088 int result;
40089 PyObject * obj0 = 0 ;
40090 char *kwnames[] = {
40091 (char *) "self", NULL
40092 };
40093
40094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40096 if (SWIG_arg_fail(1)) SWIG_fail;
40097 {
40098 PyThreadState* __tstate = wxPyBeginAllowThreads();
40099 result = (int)(arg1)->GetFlag();
40100
40101 wxPyEndAllowThreads(__tstate);
40102 if (PyErr_Occurred()) SWIG_fail;
40103 }
40104 {
40105 resultobj = SWIG_From_int(static_cast<int >(result));
40106 }
40107 return resultobj;
40108 fail:
40109 return NULL;
40110 }
40111
40112
40113 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40114 PyObject *resultobj = NULL;
40115 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40116 int arg2 ;
40117 PyObject * obj0 = 0 ;
40118 PyObject * obj1 = 0 ;
40119 char *kwnames[] = {
40120 (char *) "self",(char *) "border", NULL
40121 };
40122
40123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40125 if (SWIG_arg_fail(1)) SWIG_fail;
40126 {
40127 arg2 = static_cast<int >(SWIG_As_int(obj1));
40128 if (SWIG_arg_fail(2)) SWIG_fail;
40129 }
40130 {
40131 PyThreadState* __tstate = wxPyBeginAllowThreads();
40132 (arg1)->SetBorder(arg2);
40133
40134 wxPyEndAllowThreads(__tstate);
40135 if (PyErr_Occurred()) SWIG_fail;
40136 }
40137 Py_INCREF(Py_None); resultobj = Py_None;
40138 return resultobj;
40139 fail:
40140 return NULL;
40141 }
40142
40143
40144 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40145 PyObject *resultobj = NULL;
40146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40147 int result;
40148 PyObject * obj0 = 0 ;
40149 char *kwnames[] = {
40150 (char *) "self", NULL
40151 };
40152
40153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
40154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40155 if (SWIG_arg_fail(1)) SWIG_fail;
40156 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 result = (int)(arg1)->GetBorder();
40159
40160 wxPyEndAllowThreads(__tstate);
40161 if (PyErr_Occurred()) SWIG_fail;
40162 }
40163 {
40164 resultobj = SWIG_From_int(static_cast<int >(result));
40165 }
40166 return resultobj;
40167 fail:
40168 return NULL;
40169 }
40170
40171
40172 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40173 PyObject *resultobj = NULL;
40174 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40175 wxWindow *result;
40176 PyObject * obj0 = 0 ;
40177 char *kwnames[] = {
40178 (char *) "self", NULL
40179 };
40180
40181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40183 if (SWIG_arg_fail(1)) SWIG_fail;
40184 {
40185 PyThreadState* __tstate = wxPyBeginAllowThreads();
40186 result = (wxWindow *)(arg1)->GetWindow();
40187
40188 wxPyEndAllowThreads(__tstate);
40189 if (PyErr_Occurred()) SWIG_fail;
40190 }
40191 {
40192 resultobj = wxPyMake_wxObject(result, 0);
40193 }
40194 return resultobj;
40195 fail:
40196 return NULL;
40197 }
40198
40199
40200 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40201 PyObject *resultobj = NULL;
40202 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40203 wxWindow *arg2 = (wxWindow *) 0 ;
40204 PyObject * obj0 = 0 ;
40205 PyObject * obj1 = 0 ;
40206 char *kwnames[] = {
40207 (char *) "self",(char *) "window", NULL
40208 };
40209
40210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
40211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40212 if (SWIG_arg_fail(1)) SWIG_fail;
40213 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40214 if (SWIG_arg_fail(2)) SWIG_fail;
40215 {
40216 PyThreadState* __tstate = wxPyBeginAllowThreads();
40217 (arg1)->SetWindow(arg2);
40218
40219 wxPyEndAllowThreads(__tstate);
40220 if (PyErr_Occurred()) SWIG_fail;
40221 }
40222 Py_INCREF(Py_None); resultobj = Py_None;
40223 return resultobj;
40224 fail:
40225 return NULL;
40226 }
40227
40228
40229 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40230 PyObject *resultobj = NULL;
40231 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40232 wxSizer *result;
40233 PyObject * obj0 = 0 ;
40234 char *kwnames[] = {
40235 (char *) "self", NULL
40236 };
40237
40238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40240 if (SWIG_arg_fail(1)) SWIG_fail;
40241 {
40242 PyThreadState* __tstate = wxPyBeginAllowThreads();
40243 result = (wxSizer *)(arg1)->GetSizer();
40244
40245 wxPyEndAllowThreads(__tstate);
40246 if (PyErr_Occurred()) SWIG_fail;
40247 }
40248 {
40249 resultobj = wxPyMake_wxObject(result, (bool)0);
40250 }
40251 return resultobj;
40252 fail:
40253 return NULL;
40254 }
40255
40256
40257 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40258 PyObject *resultobj = NULL;
40259 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40260 wxSizer *arg2 = (wxSizer *) 0 ;
40261 PyObject * obj0 = 0 ;
40262 PyObject * obj1 = 0 ;
40263 char *kwnames[] = {
40264 (char *) "self",(char *) "sizer", NULL
40265 };
40266
40267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40269 if (SWIG_arg_fail(1)) SWIG_fail;
40270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40271 if (SWIG_arg_fail(2)) SWIG_fail;
40272 {
40273 PyThreadState* __tstate = wxPyBeginAllowThreads();
40274 (arg1)->SetSizer(arg2);
40275
40276 wxPyEndAllowThreads(__tstate);
40277 if (PyErr_Occurred()) SWIG_fail;
40278 }
40279 Py_INCREF(Py_None); resultobj = Py_None;
40280 return resultobj;
40281 fail:
40282 return NULL;
40283 }
40284
40285
40286 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40287 PyObject *resultobj = NULL;
40288 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40289 wxSize *result;
40290 PyObject * obj0 = 0 ;
40291 char *kwnames[] = {
40292 (char *) "self", NULL
40293 };
40294
40295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40297 if (SWIG_arg_fail(1)) SWIG_fail;
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 {
40301 wxSize const &_result_ref = (arg1)->GetSpacer();
40302 result = (wxSize *) &_result_ref;
40303 }
40304
40305 wxPyEndAllowThreads(__tstate);
40306 if (PyErr_Occurred()) SWIG_fail;
40307 }
40308 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40309 return resultobj;
40310 fail:
40311 return NULL;
40312 }
40313
40314
40315 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40316 PyObject *resultobj = NULL;
40317 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40318 wxSize *arg2 = 0 ;
40319 wxSize temp2 ;
40320 PyObject * obj0 = 0 ;
40321 PyObject * obj1 = 0 ;
40322 char *kwnames[] = {
40323 (char *) "self",(char *) "size", NULL
40324 };
40325
40326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40328 if (SWIG_arg_fail(1)) SWIG_fail;
40329 {
40330 arg2 = &temp2;
40331 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40332 }
40333 {
40334 PyThreadState* __tstate = wxPyBeginAllowThreads();
40335 (arg1)->SetSpacer((wxSize const &)*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_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40348 PyObject *resultobj = NULL;
40349 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40350 bool arg2 ;
40351 PyObject * obj0 = 0 ;
40352 PyObject * obj1 = 0 ;
40353 char *kwnames[] = {
40354 (char *) "self",(char *) "show", NULL
40355 };
40356
40357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40359 if (SWIG_arg_fail(1)) SWIG_fail;
40360 {
40361 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40362 if (SWIG_arg_fail(2)) SWIG_fail;
40363 }
40364 {
40365 PyThreadState* __tstate = wxPyBeginAllowThreads();
40366 (arg1)->Show(arg2);
40367
40368 wxPyEndAllowThreads(__tstate);
40369 if (PyErr_Occurred()) SWIG_fail;
40370 }
40371 Py_INCREF(Py_None); resultobj = Py_None;
40372 return resultobj;
40373 fail:
40374 return NULL;
40375 }
40376
40377
40378 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40379 PyObject *resultobj = NULL;
40380 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40381 bool result;
40382 PyObject * obj0 = 0 ;
40383 char *kwnames[] = {
40384 (char *) "self", NULL
40385 };
40386
40387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
40392 result = (bool)(arg1)->IsShown();
40393
40394 wxPyEndAllowThreads(__tstate);
40395 if (PyErr_Occurred()) SWIG_fail;
40396 }
40397 {
40398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40399 }
40400 return resultobj;
40401 fail:
40402 return NULL;
40403 }
40404
40405
40406 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40407 PyObject *resultobj = NULL;
40408 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40409 wxPoint result;
40410 PyObject * obj0 = 0 ;
40411 char *kwnames[] = {
40412 (char *) "self", NULL
40413 };
40414
40415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40417 if (SWIG_arg_fail(1)) SWIG_fail;
40418 {
40419 PyThreadState* __tstate = wxPyBeginAllowThreads();
40420 result = (arg1)->GetPosition();
40421
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 {
40426 wxPoint * resultptr;
40427 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40429 }
40430 return resultobj;
40431 fail:
40432 return NULL;
40433 }
40434
40435
40436 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40437 PyObject *resultobj = NULL;
40438 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40439 PyObject *result;
40440 PyObject * obj0 = 0 ;
40441 char *kwnames[] = {
40442 (char *) "self", NULL
40443 };
40444
40445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40447 if (SWIG_arg_fail(1)) SWIG_fail;
40448 {
40449 PyThreadState* __tstate = wxPyBeginAllowThreads();
40450 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40451
40452 wxPyEndAllowThreads(__tstate);
40453 if (PyErr_Occurred()) SWIG_fail;
40454 }
40455 resultobj = result;
40456 return resultobj;
40457 fail:
40458 return NULL;
40459 }
40460
40461
40462 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40463 PyObject *resultobj = NULL;
40464 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40465 PyObject *arg2 = (PyObject *) 0 ;
40466 PyObject * obj0 = 0 ;
40467 PyObject * obj1 = 0 ;
40468 char *kwnames[] = {
40469 (char *) "self",(char *) "userData", NULL
40470 };
40471
40472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40474 if (SWIG_arg_fail(1)) SWIG_fail;
40475 arg2 = obj1;
40476 {
40477 PyThreadState* __tstate = wxPyBeginAllowThreads();
40478 wxSizerItem_SetUserData(arg1,arg2);
40479
40480 wxPyEndAllowThreads(__tstate);
40481 if (PyErr_Occurred()) SWIG_fail;
40482 }
40483 Py_INCREF(Py_None); resultobj = Py_None;
40484 return resultobj;
40485 fail:
40486 return NULL;
40487 }
40488
40489
40490 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40491 PyObject *obj;
40492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40493 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40494 Py_INCREF(obj);
40495 return Py_BuildValue((char *)"");
40496 }
40497 static PyObject *_wrap_delete_Sizer(PyObject *, PyObject *args, PyObject *kwargs) {
40498 PyObject *resultobj = NULL;
40499 wxSizer *arg1 = (wxSizer *) 0 ;
40500 PyObject * obj0 = 0 ;
40501 char *kwnames[] = {
40502 (char *) "self", NULL
40503 };
40504
40505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sizer",kwnames,&obj0)) goto fail;
40506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40507 if (SWIG_arg_fail(1)) SWIG_fail;
40508 {
40509 PyThreadState* __tstate = wxPyBeginAllowThreads();
40510 delete arg1;
40511
40512 wxPyEndAllowThreads(__tstate);
40513 if (PyErr_Occurred()) SWIG_fail;
40514 }
40515 Py_INCREF(Py_None); resultobj = Py_None;
40516 return resultobj;
40517 fail:
40518 return NULL;
40519 }
40520
40521
40522 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40523 PyObject *resultobj = NULL;
40524 wxSizer *arg1 = (wxSizer *) 0 ;
40525 PyObject *arg2 = (PyObject *) 0 ;
40526 PyObject * obj0 = 0 ;
40527 PyObject * obj1 = 0 ;
40528 char *kwnames[] = {
40529 (char *) "self",(char *) "_self", NULL
40530 };
40531
40532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40534 if (SWIG_arg_fail(1)) SWIG_fail;
40535 arg2 = obj1;
40536 {
40537 PyThreadState* __tstate = wxPyBeginAllowThreads();
40538 wxSizer__setOORInfo(arg1,arg2);
40539
40540 wxPyEndAllowThreads(__tstate);
40541 if (PyErr_Occurred()) SWIG_fail;
40542 }
40543 Py_INCREF(Py_None); resultobj = Py_None;
40544 return resultobj;
40545 fail:
40546 return NULL;
40547 }
40548
40549
40550 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40551 PyObject *resultobj = NULL;
40552 wxSizer *arg1 = (wxSizer *) 0 ;
40553 PyObject *arg2 = (PyObject *) 0 ;
40554 int arg3 = (int) 0 ;
40555 int arg4 = (int) 0 ;
40556 int arg5 = (int) 0 ;
40557 PyObject *arg6 = (PyObject *) NULL ;
40558 wxSizerItem *result;
40559 PyObject * obj0 = 0 ;
40560 PyObject * obj1 = 0 ;
40561 PyObject * obj2 = 0 ;
40562 PyObject * obj3 = 0 ;
40563 PyObject * obj4 = 0 ;
40564 PyObject * obj5 = 0 ;
40565 char *kwnames[] = {
40566 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40567 };
40568
40569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40571 if (SWIG_arg_fail(1)) SWIG_fail;
40572 arg2 = obj1;
40573 if (obj2) {
40574 {
40575 arg3 = static_cast<int >(SWIG_As_int(obj2));
40576 if (SWIG_arg_fail(3)) SWIG_fail;
40577 }
40578 }
40579 if (obj3) {
40580 {
40581 arg4 = static_cast<int >(SWIG_As_int(obj3));
40582 if (SWIG_arg_fail(4)) SWIG_fail;
40583 }
40584 }
40585 if (obj4) {
40586 {
40587 arg5 = static_cast<int >(SWIG_As_int(obj4));
40588 if (SWIG_arg_fail(5)) SWIG_fail;
40589 }
40590 }
40591 if (obj5) {
40592 arg6 = obj5;
40593 }
40594 {
40595 PyThreadState* __tstate = wxPyBeginAllowThreads();
40596 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40597
40598 wxPyEndAllowThreads(__tstate);
40599 if (PyErr_Occurred()) SWIG_fail;
40600 }
40601 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40602 return resultobj;
40603 fail:
40604 return NULL;
40605 }
40606
40607
40608 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40609 PyObject *resultobj = NULL;
40610 wxSizer *arg1 = (wxSizer *) 0 ;
40611 int arg2 ;
40612 PyObject *arg3 = (PyObject *) 0 ;
40613 int arg4 = (int) 0 ;
40614 int arg5 = (int) 0 ;
40615 int arg6 = (int) 0 ;
40616 PyObject *arg7 = (PyObject *) NULL ;
40617 wxSizerItem *result;
40618 PyObject * obj0 = 0 ;
40619 PyObject * obj1 = 0 ;
40620 PyObject * obj2 = 0 ;
40621 PyObject * obj3 = 0 ;
40622 PyObject * obj4 = 0 ;
40623 PyObject * obj5 = 0 ;
40624 PyObject * obj6 = 0 ;
40625 char *kwnames[] = {
40626 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40627 };
40628
40629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40631 if (SWIG_arg_fail(1)) SWIG_fail;
40632 {
40633 arg2 = static_cast<int >(SWIG_As_int(obj1));
40634 if (SWIG_arg_fail(2)) SWIG_fail;
40635 }
40636 arg3 = obj2;
40637 if (obj3) {
40638 {
40639 arg4 = static_cast<int >(SWIG_As_int(obj3));
40640 if (SWIG_arg_fail(4)) SWIG_fail;
40641 }
40642 }
40643 if (obj4) {
40644 {
40645 arg5 = static_cast<int >(SWIG_As_int(obj4));
40646 if (SWIG_arg_fail(5)) SWIG_fail;
40647 }
40648 }
40649 if (obj5) {
40650 {
40651 arg6 = static_cast<int >(SWIG_As_int(obj5));
40652 if (SWIG_arg_fail(6)) SWIG_fail;
40653 }
40654 }
40655 if (obj6) {
40656 arg7 = obj6;
40657 }
40658 {
40659 PyThreadState* __tstate = wxPyBeginAllowThreads();
40660 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40661
40662 wxPyEndAllowThreads(__tstate);
40663 if (PyErr_Occurred()) SWIG_fail;
40664 }
40665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40666 return resultobj;
40667 fail:
40668 return NULL;
40669 }
40670
40671
40672 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40673 PyObject *resultobj = NULL;
40674 wxSizer *arg1 = (wxSizer *) 0 ;
40675 PyObject *arg2 = (PyObject *) 0 ;
40676 int arg3 = (int) 0 ;
40677 int arg4 = (int) 0 ;
40678 int arg5 = (int) 0 ;
40679 PyObject *arg6 = (PyObject *) NULL ;
40680 wxSizerItem *result;
40681 PyObject * obj0 = 0 ;
40682 PyObject * obj1 = 0 ;
40683 PyObject * obj2 = 0 ;
40684 PyObject * obj3 = 0 ;
40685 PyObject * obj4 = 0 ;
40686 PyObject * obj5 = 0 ;
40687 char *kwnames[] = {
40688 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40689 };
40690
40691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40693 if (SWIG_arg_fail(1)) SWIG_fail;
40694 arg2 = obj1;
40695 if (obj2) {
40696 {
40697 arg3 = static_cast<int >(SWIG_As_int(obj2));
40698 if (SWIG_arg_fail(3)) SWIG_fail;
40699 }
40700 }
40701 if (obj3) {
40702 {
40703 arg4 = static_cast<int >(SWIG_As_int(obj3));
40704 if (SWIG_arg_fail(4)) SWIG_fail;
40705 }
40706 }
40707 if (obj4) {
40708 {
40709 arg5 = static_cast<int >(SWIG_As_int(obj4));
40710 if (SWIG_arg_fail(5)) SWIG_fail;
40711 }
40712 }
40713 if (obj5) {
40714 arg6 = obj5;
40715 }
40716 {
40717 PyThreadState* __tstate = wxPyBeginAllowThreads();
40718 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40719
40720 wxPyEndAllowThreads(__tstate);
40721 if (PyErr_Occurred()) SWIG_fail;
40722 }
40723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40724 return resultobj;
40725 fail:
40726 return NULL;
40727 }
40728
40729
40730 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40731 PyObject *resultobj = NULL;
40732 wxSizer *arg1 = (wxSizer *) 0 ;
40733 PyObject *arg2 = (PyObject *) 0 ;
40734 bool result;
40735 PyObject * obj0 = 0 ;
40736 PyObject * obj1 = 0 ;
40737 char *kwnames[] = {
40738 (char *) "self",(char *) "item", NULL
40739 };
40740
40741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40743 if (SWIG_arg_fail(1)) SWIG_fail;
40744 arg2 = obj1;
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 result = (bool)wxSizer_Remove(arg1,arg2);
40748
40749 wxPyEndAllowThreads(__tstate);
40750 if (PyErr_Occurred()) SWIG_fail;
40751 }
40752 {
40753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40754 }
40755 return resultobj;
40756 fail:
40757 return NULL;
40758 }
40759
40760
40761 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40762 PyObject *resultobj = NULL;
40763 wxSizer *arg1 = (wxSizer *) 0 ;
40764 PyObject *arg2 = (PyObject *) 0 ;
40765 bool result;
40766 PyObject * obj0 = 0 ;
40767 PyObject * obj1 = 0 ;
40768 char *kwnames[] = {
40769 (char *) "self",(char *) "item", NULL
40770 };
40771
40772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40774 if (SWIG_arg_fail(1)) SWIG_fail;
40775 arg2 = obj1;
40776 {
40777 PyThreadState* __tstate = wxPyBeginAllowThreads();
40778 result = (bool)wxSizer_Detach(arg1,arg2);
40779
40780 wxPyEndAllowThreads(__tstate);
40781 if (PyErr_Occurred()) SWIG_fail;
40782 }
40783 {
40784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40785 }
40786 return resultobj;
40787 fail:
40788 return NULL;
40789 }
40790
40791
40792 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40793 PyObject *resultobj = NULL;
40794 wxSizer *arg1 = (wxSizer *) 0 ;
40795 PyObject *arg2 = (PyObject *) 0 ;
40796 wxSizerItem *result;
40797 PyObject * obj0 = 0 ;
40798 PyObject * obj1 = 0 ;
40799 char *kwnames[] = {
40800 (char *) "self",(char *) "item", NULL
40801 };
40802
40803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40805 if (SWIG_arg_fail(1)) SWIG_fail;
40806 arg2 = obj1;
40807 {
40808 PyThreadState* __tstate = wxPyBeginAllowThreads();
40809 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40810
40811 wxPyEndAllowThreads(__tstate);
40812 if (PyErr_Occurred()) SWIG_fail;
40813 }
40814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40815 return resultobj;
40816 fail:
40817 return NULL;
40818 }
40819
40820
40821 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40822 PyObject *resultobj = NULL;
40823 wxSizer *arg1 = (wxSizer *) 0 ;
40824 PyObject *arg2 = (PyObject *) 0 ;
40825 wxSize *arg3 = 0 ;
40826 wxSize temp3 ;
40827 PyObject * obj0 = 0 ;
40828 PyObject * obj1 = 0 ;
40829 PyObject * obj2 = 0 ;
40830 char *kwnames[] = {
40831 (char *) "self",(char *) "item",(char *) "size", NULL
40832 };
40833
40834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40836 if (SWIG_arg_fail(1)) SWIG_fail;
40837 arg2 = obj1;
40838 {
40839 arg3 = &temp3;
40840 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40841 }
40842 {
40843 PyThreadState* __tstate = wxPyBeginAllowThreads();
40844 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40845
40846 wxPyEndAllowThreads(__tstate);
40847 if (PyErr_Occurred()) SWIG_fail;
40848 }
40849 Py_INCREF(Py_None); resultobj = Py_None;
40850 return resultobj;
40851 fail:
40852 return NULL;
40853 }
40854
40855
40856 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40857 PyObject *resultobj = NULL;
40858 wxSizer *arg1 = (wxSizer *) 0 ;
40859 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40860 wxSizerItem *result;
40861 PyObject * obj0 = 0 ;
40862 PyObject * obj1 = 0 ;
40863 char *kwnames[] = {
40864 (char *) "self",(char *) "item", NULL
40865 };
40866
40867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40869 if (SWIG_arg_fail(1)) SWIG_fail;
40870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40871 if (SWIG_arg_fail(2)) SWIG_fail;
40872 {
40873 PyThreadState* __tstate = wxPyBeginAllowThreads();
40874 result = (wxSizerItem *)(arg1)->Add(arg2);
40875
40876 wxPyEndAllowThreads(__tstate);
40877 if (PyErr_Occurred()) SWIG_fail;
40878 }
40879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40880 return resultobj;
40881 fail:
40882 return NULL;
40883 }
40884
40885
40886 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40887 PyObject *resultobj = NULL;
40888 wxSizer *arg1 = (wxSizer *) 0 ;
40889 size_t arg2 ;
40890 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40891 wxSizerItem *result;
40892 PyObject * obj0 = 0 ;
40893 PyObject * obj1 = 0 ;
40894 PyObject * obj2 = 0 ;
40895 char *kwnames[] = {
40896 (char *) "self",(char *) "index",(char *) "item", NULL
40897 };
40898
40899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40901 if (SWIG_arg_fail(1)) SWIG_fail;
40902 {
40903 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40904 if (SWIG_arg_fail(2)) SWIG_fail;
40905 }
40906 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40907 if (SWIG_arg_fail(3)) SWIG_fail;
40908 {
40909 PyThreadState* __tstate = wxPyBeginAllowThreads();
40910 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40911
40912 wxPyEndAllowThreads(__tstate);
40913 if (PyErr_Occurred()) SWIG_fail;
40914 }
40915 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40916 return resultobj;
40917 fail:
40918 return NULL;
40919 }
40920
40921
40922 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40923 PyObject *resultobj = NULL;
40924 wxSizer *arg1 = (wxSizer *) 0 ;
40925 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40926 wxSizerItem *result;
40927 PyObject * obj0 = 0 ;
40928 PyObject * obj1 = 0 ;
40929 char *kwnames[] = {
40930 (char *) "self",(char *) "item", NULL
40931 };
40932
40933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40935 if (SWIG_arg_fail(1)) SWIG_fail;
40936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40937 if (SWIG_arg_fail(2)) SWIG_fail;
40938 {
40939 PyThreadState* __tstate = wxPyBeginAllowThreads();
40940 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40941
40942 wxPyEndAllowThreads(__tstate);
40943 if (PyErr_Occurred()) SWIG_fail;
40944 }
40945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40946 return resultobj;
40947 fail:
40948 return NULL;
40949 }
40950
40951
40952 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40953 PyObject *resultobj = NULL;
40954 wxSizer *arg1 = (wxSizer *) 0 ;
40955 int arg2 ;
40956 int arg3 ;
40957 int arg4 ;
40958 int arg5 ;
40959 PyObject * obj0 = 0 ;
40960 PyObject * obj1 = 0 ;
40961 PyObject * obj2 = 0 ;
40962 PyObject * obj3 = 0 ;
40963 PyObject * obj4 = 0 ;
40964 char *kwnames[] = {
40965 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40966 };
40967
40968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40970 if (SWIG_arg_fail(1)) SWIG_fail;
40971 {
40972 arg2 = static_cast<int >(SWIG_As_int(obj1));
40973 if (SWIG_arg_fail(2)) SWIG_fail;
40974 }
40975 {
40976 arg3 = static_cast<int >(SWIG_As_int(obj2));
40977 if (SWIG_arg_fail(3)) SWIG_fail;
40978 }
40979 {
40980 arg4 = static_cast<int >(SWIG_As_int(obj3));
40981 if (SWIG_arg_fail(4)) SWIG_fail;
40982 }
40983 {
40984 arg5 = static_cast<int >(SWIG_As_int(obj4));
40985 if (SWIG_arg_fail(5)) SWIG_fail;
40986 }
40987 {
40988 PyThreadState* __tstate = wxPyBeginAllowThreads();
40989 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40990
40991 wxPyEndAllowThreads(__tstate);
40992 if (PyErr_Occurred()) SWIG_fail;
40993 }
40994 Py_INCREF(Py_None); resultobj = Py_None;
40995 return resultobj;
40996 fail:
40997 return NULL;
40998 }
40999
41000
41001 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41002 PyObject *resultobj = NULL;
41003 wxSizer *arg1 = (wxSizer *) 0 ;
41004 wxSize *arg2 = 0 ;
41005 wxSize temp2 ;
41006 PyObject * obj0 = 0 ;
41007 PyObject * obj1 = 0 ;
41008 char *kwnames[] = {
41009 (char *) "self",(char *) "size", NULL
41010 };
41011
41012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
41013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41014 if (SWIG_arg_fail(1)) SWIG_fail;
41015 {
41016 arg2 = &temp2;
41017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41018 }
41019 {
41020 PyThreadState* __tstate = wxPyBeginAllowThreads();
41021 (arg1)->SetMinSize((wxSize const &)*arg2);
41022
41023 wxPyEndAllowThreads(__tstate);
41024 if (PyErr_Occurred()) SWIG_fail;
41025 }
41026 Py_INCREF(Py_None); resultobj = Py_None;
41027 return resultobj;
41028 fail:
41029 return NULL;
41030 }
41031
41032
41033 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
41034 PyObject *resultobj = NULL;
41035 wxSizer *arg1 = (wxSizer *) 0 ;
41036 wxSize result;
41037 PyObject * obj0 = 0 ;
41038 char *kwnames[] = {
41039 (char *) "self", NULL
41040 };
41041
41042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
41043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41044 if (SWIG_arg_fail(1)) SWIG_fail;
41045 {
41046 PyThreadState* __tstate = wxPyBeginAllowThreads();
41047 result = (arg1)->GetSize();
41048
41049 wxPyEndAllowThreads(__tstate);
41050 if (PyErr_Occurred()) SWIG_fail;
41051 }
41052 {
41053 wxSize * resultptr;
41054 resultptr = new wxSize(static_cast<wxSize & >(result));
41055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41056 }
41057 return resultobj;
41058 fail:
41059 return NULL;
41060 }
41061
41062
41063 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41064 PyObject *resultobj = NULL;
41065 wxSizer *arg1 = (wxSizer *) 0 ;
41066 wxPoint result;
41067 PyObject * obj0 = 0 ;
41068 char *kwnames[] = {
41069 (char *) "self", NULL
41070 };
41071
41072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
41073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41074 if (SWIG_arg_fail(1)) SWIG_fail;
41075 {
41076 PyThreadState* __tstate = wxPyBeginAllowThreads();
41077 result = (arg1)->GetPosition();
41078
41079 wxPyEndAllowThreads(__tstate);
41080 if (PyErr_Occurred()) SWIG_fail;
41081 }
41082 {
41083 wxPoint * resultptr;
41084 resultptr = new wxPoint(static_cast<wxPoint & >(result));
41085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
41086 }
41087 return resultobj;
41088 fail:
41089 return NULL;
41090 }
41091
41092
41093 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41094 PyObject *resultobj = NULL;
41095 wxSizer *arg1 = (wxSizer *) 0 ;
41096 wxSize result;
41097 PyObject * obj0 = 0 ;
41098 char *kwnames[] = {
41099 (char *) "self", NULL
41100 };
41101
41102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
41103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41104 if (SWIG_arg_fail(1)) SWIG_fail;
41105 {
41106 PyThreadState* __tstate = wxPyBeginAllowThreads();
41107 result = (arg1)->GetMinSize();
41108
41109 wxPyEndAllowThreads(__tstate);
41110 if (PyErr_Occurred()) SWIG_fail;
41111 }
41112 {
41113 wxSize * resultptr;
41114 resultptr = new wxSize(static_cast<wxSize & >(result));
41115 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41116 }
41117 return resultobj;
41118 fail:
41119 return NULL;
41120 }
41121
41122
41123 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41124 PyObject *resultobj = NULL;
41125 wxSizer *arg1 = (wxSizer *) 0 ;
41126 PyObject * obj0 = 0 ;
41127 char *kwnames[] = {
41128 (char *) "self", NULL
41129 };
41130
41131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41133 if (SWIG_arg_fail(1)) SWIG_fail;
41134 {
41135 PyThreadState* __tstate = wxPyBeginAllowThreads();
41136 (arg1)->RecalcSizes();
41137
41138 wxPyEndAllowThreads(__tstate);
41139 if (PyErr_Occurred()) SWIG_fail;
41140 }
41141 Py_INCREF(Py_None); resultobj = Py_None;
41142 return resultobj;
41143 fail:
41144 return NULL;
41145 }
41146
41147
41148 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41149 PyObject *resultobj = NULL;
41150 wxSizer *arg1 = (wxSizer *) 0 ;
41151 wxSize result;
41152 PyObject * obj0 = 0 ;
41153 char *kwnames[] = {
41154 (char *) "self", NULL
41155 };
41156
41157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41159 if (SWIG_arg_fail(1)) SWIG_fail;
41160 {
41161 PyThreadState* __tstate = wxPyBeginAllowThreads();
41162 result = (arg1)->CalcMin();
41163
41164 wxPyEndAllowThreads(__tstate);
41165 if (PyErr_Occurred()) SWIG_fail;
41166 }
41167 {
41168 wxSize * resultptr;
41169 resultptr = new wxSize(static_cast<wxSize & >(result));
41170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41171 }
41172 return resultobj;
41173 fail:
41174 return NULL;
41175 }
41176
41177
41178 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41179 PyObject *resultobj = NULL;
41180 wxSizer *arg1 = (wxSizer *) 0 ;
41181 PyObject * obj0 = 0 ;
41182 char *kwnames[] = {
41183 (char *) "self", NULL
41184 };
41185
41186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41188 if (SWIG_arg_fail(1)) SWIG_fail;
41189 {
41190 PyThreadState* __tstate = wxPyBeginAllowThreads();
41191 (arg1)->Layout();
41192
41193 wxPyEndAllowThreads(__tstate);
41194 if (PyErr_Occurred()) SWIG_fail;
41195 }
41196 Py_INCREF(Py_None); resultobj = Py_None;
41197 return resultobj;
41198 fail:
41199 return NULL;
41200 }
41201
41202
41203 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41204 PyObject *resultobj = NULL;
41205 wxSizer *arg1 = (wxSizer *) 0 ;
41206 wxWindow *arg2 = (wxWindow *) 0 ;
41207 wxSize result;
41208 PyObject * obj0 = 0 ;
41209 PyObject * obj1 = 0 ;
41210 char *kwnames[] = {
41211 (char *) "self",(char *) "window", NULL
41212 };
41213
41214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41216 if (SWIG_arg_fail(1)) SWIG_fail;
41217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41218 if (SWIG_arg_fail(2)) SWIG_fail;
41219 {
41220 PyThreadState* __tstate = wxPyBeginAllowThreads();
41221 result = (arg1)->Fit(arg2);
41222
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 {
41227 wxSize * resultptr;
41228 resultptr = new wxSize(static_cast<wxSize & >(result));
41229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41230 }
41231 return resultobj;
41232 fail:
41233 return NULL;
41234 }
41235
41236
41237 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41238 PyObject *resultobj = NULL;
41239 wxSizer *arg1 = (wxSizer *) 0 ;
41240 wxWindow *arg2 = (wxWindow *) 0 ;
41241 PyObject * obj0 = 0 ;
41242 PyObject * obj1 = 0 ;
41243 char *kwnames[] = {
41244 (char *) "self",(char *) "window", NULL
41245 };
41246
41247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41251 if (SWIG_arg_fail(2)) SWIG_fail;
41252 {
41253 PyThreadState* __tstate = wxPyBeginAllowThreads();
41254 (arg1)->FitInside(arg2);
41255
41256 wxPyEndAllowThreads(__tstate);
41257 if (PyErr_Occurred()) SWIG_fail;
41258 }
41259 Py_INCREF(Py_None); resultobj = Py_None;
41260 return resultobj;
41261 fail:
41262 return NULL;
41263 }
41264
41265
41266 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41267 PyObject *resultobj = NULL;
41268 wxSizer *arg1 = (wxSizer *) 0 ;
41269 wxWindow *arg2 = (wxWindow *) 0 ;
41270 PyObject * obj0 = 0 ;
41271 PyObject * obj1 = 0 ;
41272 char *kwnames[] = {
41273 (char *) "self",(char *) "window", NULL
41274 };
41275
41276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41278 if (SWIG_arg_fail(1)) SWIG_fail;
41279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41280 if (SWIG_arg_fail(2)) SWIG_fail;
41281 {
41282 PyThreadState* __tstate = wxPyBeginAllowThreads();
41283 (arg1)->SetSizeHints(arg2);
41284
41285 wxPyEndAllowThreads(__tstate);
41286 if (PyErr_Occurred()) SWIG_fail;
41287 }
41288 Py_INCREF(Py_None); resultobj = Py_None;
41289 return resultobj;
41290 fail:
41291 return NULL;
41292 }
41293
41294
41295 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41296 PyObject *resultobj = NULL;
41297 wxSizer *arg1 = (wxSizer *) 0 ;
41298 wxWindow *arg2 = (wxWindow *) 0 ;
41299 PyObject * obj0 = 0 ;
41300 PyObject * obj1 = 0 ;
41301 char *kwnames[] = {
41302 (char *) "self",(char *) "window", NULL
41303 };
41304
41305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41307 if (SWIG_arg_fail(1)) SWIG_fail;
41308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41309 if (SWIG_arg_fail(2)) SWIG_fail;
41310 {
41311 PyThreadState* __tstate = wxPyBeginAllowThreads();
41312 (arg1)->SetVirtualSizeHints(arg2);
41313
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 Py_INCREF(Py_None); resultobj = Py_None;
41318 return resultobj;
41319 fail:
41320 return NULL;
41321 }
41322
41323
41324 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj = NULL;
41326 wxSizer *arg1 = (wxSizer *) 0 ;
41327 bool arg2 = (bool) false ;
41328 PyObject * obj0 = 0 ;
41329 PyObject * obj1 = 0 ;
41330 char *kwnames[] = {
41331 (char *) "self",(char *) "deleteWindows", NULL
41332 };
41333
41334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41336 if (SWIG_arg_fail(1)) SWIG_fail;
41337 if (obj1) {
41338 {
41339 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41340 if (SWIG_arg_fail(2)) SWIG_fail;
41341 }
41342 }
41343 {
41344 PyThreadState* __tstate = wxPyBeginAllowThreads();
41345 (arg1)->Clear(arg2);
41346
41347 wxPyEndAllowThreads(__tstate);
41348 if (PyErr_Occurred()) SWIG_fail;
41349 }
41350 Py_INCREF(Py_None); resultobj = Py_None;
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41358 PyObject *resultobj = NULL;
41359 wxSizer *arg1 = (wxSizer *) 0 ;
41360 PyObject * obj0 = 0 ;
41361 char *kwnames[] = {
41362 (char *) "self", NULL
41363 };
41364
41365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41367 if (SWIG_arg_fail(1)) SWIG_fail;
41368 {
41369 PyThreadState* __tstate = wxPyBeginAllowThreads();
41370 (arg1)->DeleteWindows();
41371
41372 wxPyEndAllowThreads(__tstate);
41373 if (PyErr_Occurred()) SWIG_fail;
41374 }
41375 Py_INCREF(Py_None); resultobj = Py_None;
41376 return resultobj;
41377 fail:
41378 return NULL;
41379 }
41380
41381
41382 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41383 PyObject *resultobj = NULL;
41384 wxSizer *arg1 = (wxSizer *) 0 ;
41385 PyObject *result;
41386 PyObject * obj0 = 0 ;
41387 char *kwnames[] = {
41388 (char *) "self", NULL
41389 };
41390
41391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41393 if (SWIG_arg_fail(1)) SWIG_fail;
41394 {
41395 PyThreadState* __tstate = wxPyBeginAllowThreads();
41396 result = (PyObject *)wxSizer_GetChildren(arg1);
41397
41398 wxPyEndAllowThreads(__tstate);
41399 if (PyErr_Occurred()) SWIG_fail;
41400 }
41401 resultobj = result;
41402 return resultobj;
41403 fail:
41404 return NULL;
41405 }
41406
41407
41408 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41409 PyObject *resultobj = NULL;
41410 wxSizer *arg1 = (wxSizer *) 0 ;
41411 PyObject *arg2 = (PyObject *) 0 ;
41412 bool arg3 = (bool) true ;
41413 bool arg4 = (bool) false ;
41414 bool result;
41415 PyObject * obj0 = 0 ;
41416 PyObject * obj1 = 0 ;
41417 PyObject * obj2 = 0 ;
41418 PyObject * obj3 = 0 ;
41419 char *kwnames[] = {
41420 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41421 };
41422
41423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41425 if (SWIG_arg_fail(1)) SWIG_fail;
41426 arg2 = obj1;
41427 if (obj2) {
41428 {
41429 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41430 if (SWIG_arg_fail(3)) SWIG_fail;
41431 }
41432 }
41433 if (obj3) {
41434 {
41435 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41436 if (SWIG_arg_fail(4)) SWIG_fail;
41437 }
41438 }
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41442
41443 wxPyEndAllowThreads(__tstate);
41444 if (PyErr_Occurred()) SWIG_fail;
41445 }
41446 {
41447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41448 }
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41456 PyObject *resultobj = NULL;
41457 wxSizer *arg1 = (wxSizer *) 0 ;
41458 PyObject *arg2 = (PyObject *) 0 ;
41459 bool result;
41460 PyObject * obj0 = 0 ;
41461 PyObject * obj1 = 0 ;
41462 char *kwnames[] = {
41463 (char *) "self",(char *) "item", NULL
41464 };
41465
41466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41468 if (SWIG_arg_fail(1)) SWIG_fail;
41469 arg2 = obj1;
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 result = (bool)wxSizer_IsShown(arg1,arg2);
41473
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 {
41478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41479 }
41480 return resultobj;
41481 fail:
41482 return NULL;
41483 }
41484
41485
41486 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41487 PyObject *resultobj = NULL;
41488 wxSizer *arg1 = (wxSizer *) 0 ;
41489 bool arg2 ;
41490 PyObject * obj0 = 0 ;
41491 PyObject * obj1 = 0 ;
41492 char *kwnames[] = {
41493 (char *) "self",(char *) "show", NULL
41494 };
41495
41496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41498 if (SWIG_arg_fail(1)) SWIG_fail;
41499 {
41500 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41501 if (SWIG_arg_fail(2)) SWIG_fail;
41502 }
41503 {
41504 PyThreadState* __tstate = wxPyBeginAllowThreads();
41505 (arg1)->ShowItems(arg2);
41506
41507 wxPyEndAllowThreads(__tstate);
41508 if (PyErr_Occurred()) SWIG_fail;
41509 }
41510 Py_INCREF(Py_None); resultobj = Py_None;
41511 return resultobj;
41512 fail:
41513 return NULL;
41514 }
41515
41516
41517 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41518 PyObject *obj;
41519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41520 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41521 Py_INCREF(obj);
41522 return Py_BuildValue((char *)"");
41523 }
41524 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41525 PyObject *resultobj = NULL;
41526 wxPySizer *result;
41527 char *kwnames[] = {
41528 NULL
41529 };
41530
41531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41532 {
41533 PyThreadState* __tstate = wxPyBeginAllowThreads();
41534 result = (wxPySizer *)new wxPySizer();
41535
41536 wxPyEndAllowThreads(__tstate);
41537 if (PyErr_Occurred()) SWIG_fail;
41538 }
41539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41540 return resultobj;
41541 fail:
41542 return NULL;
41543 }
41544
41545
41546 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41547 PyObject *resultobj = NULL;
41548 wxPySizer *arg1 = (wxPySizer *) 0 ;
41549 PyObject *arg2 = (PyObject *) 0 ;
41550 PyObject *arg3 = (PyObject *) 0 ;
41551 PyObject * obj0 = 0 ;
41552 PyObject * obj1 = 0 ;
41553 PyObject * obj2 = 0 ;
41554 char *kwnames[] = {
41555 (char *) "self",(char *) "self",(char *) "_class", NULL
41556 };
41557
41558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41560 if (SWIG_arg_fail(1)) SWIG_fail;
41561 arg2 = obj1;
41562 arg3 = obj2;
41563 {
41564 PyThreadState* __tstate = wxPyBeginAllowThreads();
41565 (arg1)->_setCallbackInfo(arg2,arg3);
41566
41567 wxPyEndAllowThreads(__tstate);
41568 if (PyErr_Occurred()) SWIG_fail;
41569 }
41570 Py_INCREF(Py_None); resultobj = Py_None;
41571 return resultobj;
41572 fail:
41573 return NULL;
41574 }
41575
41576
41577 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41578 PyObject *obj;
41579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41580 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41581 Py_INCREF(obj);
41582 return Py_BuildValue((char *)"");
41583 }
41584 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41585 PyObject *resultobj = NULL;
41586 int arg1 = (int) wxHORIZONTAL ;
41587 wxBoxSizer *result;
41588 PyObject * obj0 = 0 ;
41589 char *kwnames[] = {
41590 (char *) "orient", NULL
41591 };
41592
41593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41594 if (obj0) {
41595 {
41596 arg1 = static_cast<int >(SWIG_As_int(obj0));
41597 if (SWIG_arg_fail(1)) SWIG_fail;
41598 }
41599 }
41600 {
41601 PyThreadState* __tstate = wxPyBeginAllowThreads();
41602 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41603
41604 wxPyEndAllowThreads(__tstate);
41605 if (PyErr_Occurred()) SWIG_fail;
41606 }
41607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41608 return resultobj;
41609 fail:
41610 return NULL;
41611 }
41612
41613
41614 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41615 PyObject *resultobj = NULL;
41616 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41617 int result;
41618 PyObject * obj0 = 0 ;
41619 char *kwnames[] = {
41620 (char *) "self", NULL
41621 };
41622
41623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41625 if (SWIG_arg_fail(1)) SWIG_fail;
41626 {
41627 PyThreadState* __tstate = wxPyBeginAllowThreads();
41628 result = (int)(arg1)->GetOrientation();
41629
41630 wxPyEndAllowThreads(__tstate);
41631 if (PyErr_Occurred()) SWIG_fail;
41632 }
41633 {
41634 resultobj = SWIG_From_int(static_cast<int >(result));
41635 }
41636 return resultobj;
41637 fail:
41638 return NULL;
41639 }
41640
41641
41642 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41643 PyObject *resultobj = NULL;
41644 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41645 int arg2 ;
41646 PyObject * obj0 = 0 ;
41647 PyObject * obj1 = 0 ;
41648 char *kwnames[] = {
41649 (char *) "self",(char *) "orient", NULL
41650 };
41651
41652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41654 if (SWIG_arg_fail(1)) SWIG_fail;
41655 {
41656 arg2 = static_cast<int >(SWIG_As_int(obj1));
41657 if (SWIG_arg_fail(2)) SWIG_fail;
41658 }
41659 {
41660 PyThreadState* __tstate = wxPyBeginAllowThreads();
41661 (arg1)->SetOrientation(arg2);
41662
41663 wxPyEndAllowThreads(__tstate);
41664 if (PyErr_Occurred()) SWIG_fail;
41665 }
41666 Py_INCREF(Py_None); resultobj = Py_None;
41667 return resultobj;
41668 fail:
41669 return NULL;
41670 }
41671
41672
41673 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41674 PyObject *obj;
41675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41676 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41677 Py_INCREF(obj);
41678 return Py_BuildValue((char *)"");
41679 }
41680 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41681 PyObject *resultobj = NULL;
41682 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41683 int arg2 = (int) wxHORIZONTAL ;
41684 wxStaticBoxSizer *result;
41685 PyObject * obj0 = 0 ;
41686 PyObject * obj1 = 0 ;
41687 char *kwnames[] = {
41688 (char *) "box",(char *) "orient", NULL
41689 };
41690
41691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41693 if (SWIG_arg_fail(1)) SWIG_fail;
41694 if (obj1) {
41695 {
41696 arg2 = static_cast<int >(SWIG_As_int(obj1));
41697 if (SWIG_arg_fail(2)) SWIG_fail;
41698 }
41699 }
41700 {
41701 PyThreadState* __tstate = wxPyBeginAllowThreads();
41702 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41703
41704 wxPyEndAllowThreads(__tstate);
41705 if (PyErr_Occurred()) SWIG_fail;
41706 }
41707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41715 PyObject *resultobj = NULL;
41716 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41717 wxStaticBox *result;
41718 PyObject * obj0 = 0 ;
41719 char *kwnames[] = {
41720 (char *) "self", NULL
41721 };
41722
41723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41725 if (SWIG_arg_fail(1)) SWIG_fail;
41726 {
41727 PyThreadState* __tstate = wxPyBeginAllowThreads();
41728 result = (wxStaticBox *)(arg1)->GetStaticBox();
41729
41730 wxPyEndAllowThreads(__tstate);
41731 if (PyErr_Occurred()) SWIG_fail;
41732 }
41733 {
41734 resultobj = wxPyMake_wxObject(result, (bool)0);
41735 }
41736 return resultobj;
41737 fail:
41738 return NULL;
41739 }
41740
41741
41742 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41743 PyObject *obj;
41744 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41745 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41746 Py_INCREF(obj);
41747 return Py_BuildValue((char *)"");
41748 }
41749 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41750 PyObject *resultobj = NULL;
41751 int arg1 = (int) 1 ;
41752 int arg2 = (int) 0 ;
41753 int arg3 = (int) 0 ;
41754 int arg4 = (int) 0 ;
41755 wxGridSizer *result;
41756 PyObject * obj0 = 0 ;
41757 PyObject * obj1 = 0 ;
41758 PyObject * obj2 = 0 ;
41759 PyObject * obj3 = 0 ;
41760 char *kwnames[] = {
41761 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41762 };
41763
41764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41765 if (obj0) {
41766 {
41767 arg1 = static_cast<int >(SWIG_As_int(obj0));
41768 if (SWIG_arg_fail(1)) SWIG_fail;
41769 }
41770 }
41771 if (obj1) {
41772 {
41773 arg2 = static_cast<int >(SWIG_As_int(obj1));
41774 if (SWIG_arg_fail(2)) SWIG_fail;
41775 }
41776 }
41777 if (obj2) {
41778 {
41779 arg3 = static_cast<int >(SWIG_As_int(obj2));
41780 if (SWIG_arg_fail(3)) SWIG_fail;
41781 }
41782 }
41783 if (obj3) {
41784 {
41785 arg4 = static_cast<int >(SWIG_As_int(obj3));
41786 if (SWIG_arg_fail(4)) SWIG_fail;
41787 }
41788 }
41789 {
41790 PyThreadState* __tstate = wxPyBeginAllowThreads();
41791 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41792
41793 wxPyEndAllowThreads(__tstate);
41794 if (PyErr_Occurred()) SWIG_fail;
41795 }
41796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41797 return resultobj;
41798 fail:
41799 return NULL;
41800 }
41801
41802
41803 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41804 PyObject *resultobj = NULL;
41805 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41806 int arg2 ;
41807 PyObject * obj0 = 0 ;
41808 PyObject * obj1 = 0 ;
41809 char *kwnames[] = {
41810 (char *) "self",(char *) "cols", NULL
41811 };
41812
41813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41815 if (SWIG_arg_fail(1)) SWIG_fail;
41816 {
41817 arg2 = static_cast<int >(SWIG_As_int(obj1));
41818 if (SWIG_arg_fail(2)) SWIG_fail;
41819 }
41820 {
41821 PyThreadState* __tstate = wxPyBeginAllowThreads();
41822 (arg1)->SetCols(arg2);
41823
41824 wxPyEndAllowThreads(__tstate);
41825 if (PyErr_Occurred()) SWIG_fail;
41826 }
41827 Py_INCREF(Py_None); resultobj = Py_None;
41828 return resultobj;
41829 fail:
41830 return NULL;
41831 }
41832
41833
41834 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41835 PyObject *resultobj = NULL;
41836 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41837 int arg2 ;
41838 PyObject * obj0 = 0 ;
41839 PyObject * obj1 = 0 ;
41840 char *kwnames[] = {
41841 (char *) "self",(char *) "rows", NULL
41842 };
41843
41844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41846 if (SWIG_arg_fail(1)) SWIG_fail;
41847 {
41848 arg2 = static_cast<int >(SWIG_As_int(obj1));
41849 if (SWIG_arg_fail(2)) SWIG_fail;
41850 }
41851 {
41852 PyThreadState* __tstate = wxPyBeginAllowThreads();
41853 (arg1)->SetRows(arg2);
41854
41855 wxPyEndAllowThreads(__tstate);
41856 if (PyErr_Occurred()) SWIG_fail;
41857 }
41858 Py_INCREF(Py_None); resultobj = Py_None;
41859 return resultobj;
41860 fail:
41861 return NULL;
41862 }
41863
41864
41865 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41866 PyObject *resultobj = NULL;
41867 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41868 int arg2 ;
41869 PyObject * obj0 = 0 ;
41870 PyObject * obj1 = 0 ;
41871 char *kwnames[] = {
41872 (char *) "self",(char *) "gap", NULL
41873 };
41874
41875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41877 if (SWIG_arg_fail(1)) SWIG_fail;
41878 {
41879 arg2 = static_cast<int >(SWIG_As_int(obj1));
41880 if (SWIG_arg_fail(2)) SWIG_fail;
41881 }
41882 {
41883 PyThreadState* __tstate = wxPyBeginAllowThreads();
41884 (arg1)->SetVGap(arg2);
41885
41886 wxPyEndAllowThreads(__tstate);
41887 if (PyErr_Occurred()) SWIG_fail;
41888 }
41889 Py_INCREF(Py_None); resultobj = Py_None;
41890 return resultobj;
41891 fail:
41892 return NULL;
41893 }
41894
41895
41896 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41897 PyObject *resultobj = NULL;
41898 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41899 int arg2 ;
41900 PyObject * obj0 = 0 ;
41901 PyObject * obj1 = 0 ;
41902 char *kwnames[] = {
41903 (char *) "self",(char *) "gap", NULL
41904 };
41905
41906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41908 if (SWIG_arg_fail(1)) SWIG_fail;
41909 {
41910 arg2 = static_cast<int >(SWIG_As_int(obj1));
41911 if (SWIG_arg_fail(2)) SWIG_fail;
41912 }
41913 {
41914 PyThreadState* __tstate = wxPyBeginAllowThreads();
41915 (arg1)->SetHGap(arg2);
41916
41917 wxPyEndAllowThreads(__tstate);
41918 if (PyErr_Occurred()) SWIG_fail;
41919 }
41920 Py_INCREF(Py_None); resultobj = Py_None;
41921 return resultobj;
41922 fail:
41923 return NULL;
41924 }
41925
41926
41927 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41928 PyObject *resultobj = NULL;
41929 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41930 int result;
41931 PyObject * obj0 = 0 ;
41932 char *kwnames[] = {
41933 (char *) "self", NULL
41934 };
41935
41936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
41941 result = (int)(arg1)->GetCols();
41942
41943 wxPyEndAllowThreads(__tstate);
41944 if (PyErr_Occurred()) SWIG_fail;
41945 }
41946 {
41947 resultobj = SWIG_From_int(static_cast<int >(result));
41948 }
41949 return resultobj;
41950 fail:
41951 return NULL;
41952 }
41953
41954
41955 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41956 PyObject *resultobj = NULL;
41957 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41958 int result;
41959 PyObject * obj0 = 0 ;
41960 char *kwnames[] = {
41961 (char *) "self", NULL
41962 };
41963
41964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41966 if (SWIG_arg_fail(1)) SWIG_fail;
41967 {
41968 PyThreadState* __tstate = wxPyBeginAllowThreads();
41969 result = (int)(arg1)->GetRows();
41970
41971 wxPyEndAllowThreads(__tstate);
41972 if (PyErr_Occurred()) SWIG_fail;
41973 }
41974 {
41975 resultobj = SWIG_From_int(static_cast<int >(result));
41976 }
41977 return resultobj;
41978 fail:
41979 return NULL;
41980 }
41981
41982
41983 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41984 PyObject *resultobj = NULL;
41985 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41986 int result;
41987 PyObject * obj0 = 0 ;
41988 char *kwnames[] = {
41989 (char *) "self", NULL
41990 };
41991
41992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41994 if (SWIG_arg_fail(1)) SWIG_fail;
41995 {
41996 PyThreadState* __tstate = wxPyBeginAllowThreads();
41997 result = (int)(arg1)->GetVGap();
41998
41999 wxPyEndAllowThreads(__tstate);
42000 if (PyErr_Occurred()) SWIG_fail;
42001 }
42002 {
42003 resultobj = SWIG_From_int(static_cast<int >(result));
42004 }
42005 return resultobj;
42006 fail:
42007 return NULL;
42008 }
42009
42010
42011 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
42012 PyObject *resultobj = NULL;
42013 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
42014 int result;
42015 PyObject * obj0 = 0 ;
42016 char *kwnames[] = {
42017 (char *) "self", NULL
42018 };
42019
42020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
42021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
42022 if (SWIG_arg_fail(1)) SWIG_fail;
42023 {
42024 PyThreadState* __tstate = wxPyBeginAllowThreads();
42025 result = (int)(arg1)->GetHGap();
42026
42027 wxPyEndAllowThreads(__tstate);
42028 if (PyErr_Occurred()) SWIG_fail;
42029 }
42030 {
42031 resultobj = SWIG_From_int(static_cast<int >(result));
42032 }
42033 return resultobj;
42034 fail:
42035 return NULL;
42036 }
42037
42038
42039 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
42040 PyObject *obj;
42041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42042 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
42043 Py_INCREF(obj);
42044 return Py_BuildValue((char *)"");
42045 }
42046 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42047 PyObject *resultobj = NULL;
42048 int arg1 = (int) 1 ;
42049 int arg2 = (int) 0 ;
42050 int arg3 = (int) 0 ;
42051 int arg4 = (int) 0 ;
42052 wxFlexGridSizer *result;
42053 PyObject * obj0 = 0 ;
42054 PyObject * obj1 = 0 ;
42055 PyObject * obj2 = 0 ;
42056 PyObject * obj3 = 0 ;
42057 char *kwnames[] = {
42058 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
42059 };
42060
42061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42062 if (obj0) {
42063 {
42064 arg1 = static_cast<int >(SWIG_As_int(obj0));
42065 if (SWIG_arg_fail(1)) SWIG_fail;
42066 }
42067 }
42068 if (obj1) {
42069 {
42070 arg2 = static_cast<int >(SWIG_As_int(obj1));
42071 if (SWIG_arg_fail(2)) SWIG_fail;
42072 }
42073 }
42074 if (obj2) {
42075 {
42076 arg3 = static_cast<int >(SWIG_As_int(obj2));
42077 if (SWIG_arg_fail(3)) SWIG_fail;
42078 }
42079 }
42080 if (obj3) {
42081 {
42082 arg4 = static_cast<int >(SWIG_As_int(obj3));
42083 if (SWIG_arg_fail(4)) SWIG_fail;
42084 }
42085 }
42086 {
42087 PyThreadState* __tstate = wxPyBeginAllowThreads();
42088 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
42089
42090 wxPyEndAllowThreads(__tstate);
42091 if (PyErr_Occurred()) SWIG_fail;
42092 }
42093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
42094 return resultobj;
42095 fail:
42096 return NULL;
42097 }
42098
42099
42100 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42101 PyObject *resultobj = NULL;
42102 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42103 size_t arg2 ;
42104 int arg3 = (int) 0 ;
42105 PyObject * obj0 = 0 ;
42106 PyObject * obj1 = 0 ;
42107 PyObject * obj2 = 0 ;
42108 char *kwnames[] = {
42109 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42110 };
42111
42112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42114 if (SWIG_arg_fail(1)) SWIG_fail;
42115 {
42116 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42117 if (SWIG_arg_fail(2)) SWIG_fail;
42118 }
42119 if (obj2) {
42120 {
42121 arg3 = static_cast<int >(SWIG_As_int(obj2));
42122 if (SWIG_arg_fail(3)) SWIG_fail;
42123 }
42124 }
42125 {
42126 PyThreadState* __tstate = wxPyBeginAllowThreads();
42127 (arg1)->AddGrowableRow(arg2,arg3);
42128
42129 wxPyEndAllowThreads(__tstate);
42130 if (PyErr_Occurred()) SWIG_fail;
42131 }
42132 Py_INCREF(Py_None); resultobj = Py_None;
42133 return resultobj;
42134 fail:
42135 return NULL;
42136 }
42137
42138
42139 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42140 PyObject *resultobj = NULL;
42141 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42142 size_t arg2 ;
42143 PyObject * obj0 = 0 ;
42144 PyObject * obj1 = 0 ;
42145 char *kwnames[] = {
42146 (char *) "self",(char *) "idx", NULL
42147 };
42148
42149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42151 if (SWIG_arg_fail(1)) SWIG_fail;
42152 {
42153 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42154 if (SWIG_arg_fail(2)) SWIG_fail;
42155 }
42156 {
42157 PyThreadState* __tstate = wxPyBeginAllowThreads();
42158 (arg1)->RemoveGrowableRow(arg2);
42159
42160 wxPyEndAllowThreads(__tstate);
42161 if (PyErr_Occurred()) SWIG_fail;
42162 }
42163 Py_INCREF(Py_None); resultobj = Py_None;
42164 return resultobj;
42165 fail:
42166 return NULL;
42167 }
42168
42169
42170 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42171 PyObject *resultobj = NULL;
42172 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42173 size_t arg2 ;
42174 int arg3 = (int) 0 ;
42175 PyObject * obj0 = 0 ;
42176 PyObject * obj1 = 0 ;
42177 PyObject * obj2 = 0 ;
42178 char *kwnames[] = {
42179 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42180 };
42181
42182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42184 if (SWIG_arg_fail(1)) SWIG_fail;
42185 {
42186 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42187 if (SWIG_arg_fail(2)) SWIG_fail;
42188 }
42189 if (obj2) {
42190 {
42191 arg3 = static_cast<int >(SWIG_As_int(obj2));
42192 if (SWIG_arg_fail(3)) SWIG_fail;
42193 }
42194 }
42195 {
42196 PyThreadState* __tstate = wxPyBeginAllowThreads();
42197 (arg1)->AddGrowableCol(arg2,arg3);
42198
42199 wxPyEndAllowThreads(__tstate);
42200 if (PyErr_Occurred()) SWIG_fail;
42201 }
42202 Py_INCREF(Py_None); resultobj = Py_None;
42203 return resultobj;
42204 fail:
42205 return NULL;
42206 }
42207
42208
42209 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42210 PyObject *resultobj = NULL;
42211 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42212 size_t arg2 ;
42213 PyObject * obj0 = 0 ;
42214 PyObject * obj1 = 0 ;
42215 char *kwnames[] = {
42216 (char *) "self",(char *) "idx", NULL
42217 };
42218
42219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42221 if (SWIG_arg_fail(1)) SWIG_fail;
42222 {
42223 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42224 if (SWIG_arg_fail(2)) SWIG_fail;
42225 }
42226 {
42227 PyThreadState* __tstate = wxPyBeginAllowThreads();
42228 (arg1)->RemoveGrowableCol(arg2);
42229
42230 wxPyEndAllowThreads(__tstate);
42231 if (PyErr_Occurred()) SWIG_fail;
42232 }
42233 Py_INCREF(Py_None); resultobj = Py_None;
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42241 PyObject *resultobj = NULL;
42242 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42243 int arg2 ;
42244 PyObject * obj0 = 0 ;
42245 PyObject * obj1 = 0 ;
42246 char *kwnames[] = {
42247 (char *) "self",(char *) "direction", NULL
42248 };
42249
42250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42252 if (SWIG_arg_fail(1)) SWIG_fail;
42253 {
42254 arg2 = static_cast<int >(SWIG_As_int(obj1));
42255 if (SWIG_arg_fail(2)) SWIG_fail;
42256 }
42257 {
42258 PyThreadState* __tstate = wxPyBeginAllowThreads();
42259 (arg1)->SetFlexibleDirection(arg2);
42260
42261 wxPyEndAllowThreads(__tstate);
42262 if (PyErr_Occurred()) SWIG_fail;
42263 }
42264 Py_INCREF(Py_None); resultobj = Py_None;
42265 return resultobj;
42266 fail:
42267 return NULL;
42268 }
42269
42270
42271 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42272 PyObject *resultobj = NULL;
42273 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42274 int result;
42275 PyObject * obj0 = 0 ;
42276 char *kwnames[] = {
42277 (char *) "self", NULL
42278 };
42279
42280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
42285 result = (int)(arg1)->GetFlexibleDirection();
42286
42287 wxPyEndAllowThreads(__tstate);
42288 if (PyErr_Occurred()) SWIG_fail;
42289 }
42290 {
42291 resultobj = SWIG_From_int(static_cast<int >(result));
42292 }
42293 return resultobj;
42294 fail:
42295 return NULL;
42296 }
42297
42298
42299 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42300 PyObject *resultobj = NULL;
42301 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42302 wxFlexSizerGrowMode arg2 ;
42303 PyObject * obj0 = 0 ;
42304 PyObject * obj1 = 0 ;
42305 char *kwnames[] = {
42306 (char *) "self",(char *) "mode", NULL
42307 };
42308
42309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42311 if (SWIG_arg_fail(1)) SWIG_fail;
42312 {
42313 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42314 if (SWIG_arg_fail(2)) SWIG_fail;
42315 }
42316 {
42317 PyThreadState* __tstate = wxPyBeginAllowThreads();
42318 (arg1)->SetNonFlexibleGrowMode(arg2);
42319
42320 wxPyEndAllowThreads(__tstate);
42321 if (PyErr_Occurred()) SWIG_fail;
42322 }
42323 Py_INCREF(Py_None); resultobj = Py_None;
42324 return resultobj;
42325 fail:
42326 return NULL;
42327 }
42328
42329
42330 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42331 PyObject *resultobj = NULL;
42332 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42333 wxFlexSizerGrowMode result;
42334 PyObject * obj0 = 0 ;
42335 char *kwnames[] = {
42336 (char *) "self", NULL
42337 };
42338
42339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42341 if (SWIG_arg_fail(1)) SWIG_fail;
42342 {
42343 PyThreadState* __tstate = wxPyBeginAllowThreads();
42344 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42345
42346 wxPyEndAllowThreads(__tstate);
42347 if (PyErr_Occurred()) SWIG_fail;
42348 }
42349 resultobj = SWIG_From_int((result));
42350 return resultobj;
42351 fail:
42352 return NULL;
42353 }
42354
42355
42356 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42357 PyObject *resultobj = NULL;
42358 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42359 wxArrayInt *result;
42360 PyObject * obj0 = 0 ;
42361 char *kwnames[] = {
42362 (char *) "self", NULL
42363 };
42364
42365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42367 if (SWIG_arg_fail(1)) SWIG_fail;
42368 {
42369 PyThreadState* __tstate = wxPyBeginAllowThreads();
42370 {
42371 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42372 result = (wxArrayInt *) &_result_ref;
42373 }
42374
42375 wxPyEndAllowThreads(__tstate);
42376 if (PyErr_Occurred()) SWIG_fail;
42377 }
42378 {
42379 resultobj = PyList_New(0);
42380 size_t idx;
42381 for (idx = 0; idx < result->GetCount(); idx += 1) {
42382 PyObject* val = PyInt_FromLong( result->Item(idx) );
42383 PyList_Append(resultobj, val);
42384 Py_DECREF(val);
42385 }
42386 }
42387 return resultobj;
42388 fail:
42389 return NULL;
42390 }
42391
42392
42393 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42394 PyObject *resultobj = NULL;
42395 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42396 wxArrayInt *result;
42397 PyObject * obj0 = 0 ;
42398 char *kwnames[] = {
42399 (char *) "self", NULL
42400 };
42401
42402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42404 if (SWIG_arg_fail(1)) SWIG_fail;
42405 {
42406 PyThreadState* __tstate = wxPyBeginAllowThreads();
42407 {
42408 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42409 result = (wxArrayInt *) &_result_ref;
42410 }
42411
42412 wxPyEndAllowThreads(__tstate);
42413 if (PyErr_Occurred()) SWIG_fail;
42414 }
42415 {
42416 resultobj = PyList_New(0);
42417 size_t idx;
42418 for (idx = 0; idx < result->GetCount(); idx += 1) {
42419 PyObject* val = PyInt_FromLong( result->Item(idx) );
42420 PyList_Append(resultobj, val);
42421 Py_DECREF(val);
42422 }
42423 }
42424 return resultobj;
42425 fail:
42426 return NULL;
42427 }
42428
42429
42430 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42431 PyObject *obj;
42432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42433 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42434 Py_INCREF(obj);
42435 return Py_BuildValue((char *)"");
42436 }
42437 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42438 PyObject *resultobj = NULL;
42439 wxStdDialogButtonSizer *result;
42440 char *kwnames[] = {
42441 NULL
42442 };
42443
42444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42445 {
42446 PyThreadState* __tstate = wxPyBeginAllowThreads();
42447 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42448
42449 wxPyEndAllowThreads(__tstate);
42450 if (PyErr_Occurred()) SWIG_fail;
42451 }
42452 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42453 return resultobj;
42454 fail:
42455 return NULL;
42456 }
42457
42458
42459 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42460 PyObject *resultobj = NULL;
42461 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42462 wxButton *arg2 = (wxButton *) 0 ;
42463 PyObject * obj0 = 0 ;
42464 PyObject * obj1 = 0 ;
42465 char *kwnames[] = {
42466 (char *) "self",(char *) "button", NULL
42467 };
42468
42469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42471 if (SWIG_arg_fail(1)) SWIG_fail;
42472 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42473 if (SWIG_arg_fail(2)) SWIG_fail;
42474 {
42475 PyThreadState* __tstate = wxPyBeginAllowThreads();
42476 (arg1)->AddButton(arg2);
42477
42478 wxPyEndAllowThreads(__tstate);
42479 if (PyErr_Occurred()) SWIG_fail;
42480 }
42481 Py_INCREF(Py_None); resultobj = Py_None;
42482 return resultobj;
42483 fail:
42484 return NULL;
42485 }
42486
42487
42488 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42489 PyObject *resultobj = NULL;
42490 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42491 PyObject * obj0 = 0 ;
42492 char *kwnames[] = {
42493 (char *) "self", NULL
42494 };
42495
42496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42498 if (SWIG_arg_fail(1)) SWIG_fail;
42499 {
42500 PyThreadState* __tstate = wxPyBeginAllowThreads();
42501 (arg1)->Realize();
42502
42503 wxPyEndAllowThreads(__tstate);
42504 if (PyErr_Occurred()) SWIG_fail;
42505 }
42506 Py_INCREF(Py_None); resultobj = Py_None;
42507 return resultobj;
42508 fail:
42509 return NULL;
42510 }
42511
42512
42513 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42514 PyObject *resultobj = NULL;
42515 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42516 wxButton *arg2 = (wxButton *) 0 ;
42517 PyObject * obj0 = 0 ;
42518 PyObject * obj1 = 0 ;
42519 char *kwnames[] = {
42520 (char *) "self",(char *) "button", NULL
42521 };
42522
42523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42525 if (SWIG_arg_fail(1)) SWIG_fail;
42526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42527 if (SWIG_arg_fail(2)) SWIG_fail;
42528 {
42529 PyThreadState* __tstate = wxPyBeginAllowThreads();
42530 (arg1)->SetAffirmativeButton(arg2);
42531
42532 wxPyEndAllowThreads(__tstate);
42533 if (PyErr_Occurred()) SWIG_fail;
42534 }
42535 Py_INCREF(Py_None); resultobj = Py_None;
42536 return resultobj;
42537 fail:
42538 return NULL;
42539 }
42540
42541
42542 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42543 PyObject *resultobj = NULL;
42544 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42545 wxButton *arg2 = (wxButton *) 0 ;
42546 PyObject * obj0 = 0 ;
42547 PyObject * obj1 = 0 ;
42548 char *kwnames[] = {
42549 (char *) "self",(char *) "button", NULL
42550 };
42551
42552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42554 if (SWIG_arg_fail(1)) SWIG_fail;
42555 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42556 if (SWIG_arg_fail(2)) SWIG_fail;
42557 {
42558 PyThreadState* __tstate = wxPyBeginAllowThreads();
42559 (arg1)->SetNegativeButton(arg2);
42560
42561 wxPyEndAllowThreads(__tstate);
42562 if (PyErr_Occurred()) SWIG_fail;
42563 }
42564 Py_INCREF(Py_None); resultobj = Py_None;
42565 return resultobj;
42566 fail:
42567 return NULL;
42568 }
42569
42570
42571 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42572 PyObject *resultobj = NULL;
42573 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42574 wxButton *arg2 = (wxButton *) 0 ;
42575 PyObject * obj0 = 0 ;
42576 PyObject * obj1 = 0 ;
42577 char *kwnames[] = {
42578 (char *) "self",(char *) "button", NULL
42579 };
42580
42581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42583 if (SWIG_arg_fail(1)) SWIG_fail;
42584 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42585 if (SWIG_arg_fail(2)) SWIG_fail;
42586 {
42587 PyThreadState* __tstate = wxPyBeginAllowThreads();
42588 (arg1)->SetCancelButton(arg2);
42589
42590 wxPyEndAllowThreads(__tstate);
42591 if (PyErr_Occurred()) SWIG_fail;
42592 }
42593 Py_INCREF(Py_None); resultobj = Py_None;
42594 return resultobj;
42595 fail:
42596 return NULL;
42597 }
42598
42599
42600 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42601 PyObject *resultobj = NULL;
42602 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42603 wxButton *result;
42604 PyObject * obj0 = 0 ;
42605 char *kwnames[] = {
42606 (char *) "self", NULL
42607 };
42608
42609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42611 if (SWIG_arg_fail(1)) SWIG_fail;
42612 {
42613 PyThreadState* __tstate = wxPyBeginAllowThreads();
42614 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42615
42616 wxPyEndAllowThreads(__tstate);
42617 if (PyErr_Occurred()) SWIG_fail;
42618 }
42619 {
42620 resultobj = wxPyMake_wxObject(result, (bool)0);
42621 }
42622 return resultobj;
42623 fail:
42624 return NULL;
42625 }
42626
42627
42628 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42629 PyObject *resultobj = NULL;
42630 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42631 wxButton *result;
42632 PyObject * obj0 = 0 ;
42633 char *kwnames[] = {
42634 (char *) "self", NULL
42635 };
42636
42637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42639 if (SWIG_arg_fail(1)) SWIG_fail;
42640 {
42641 PyThreadState* __tstate = wxPyBeginAllowThreads();
42642 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42643
42644 wxPyEndAllowThreads(__tstate);
42645 if (PyErr_Occurred()) SWIG_fail;
42646 }
42647 {
42648 resultobj = wxPyMake_wxObject(result, (bool)0);
42649 }
42650 return resultobj;
42651 fail:
42652 return NULL;
42653 }
42654
42655
42656 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42657 PyObject *resultobj = NULL;
42658 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42659 wxButton *result;
42660 PyObject * obj0 = 0 ;
42661 char *kwnames[] = {
42662 (char *) "self", NULL
42663 };
42664
42665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42667 if (SWIG_arg_fail(1)) SWIG_fail;
42668 {
42669 PyThreadState* __tstate = wxPyBeginAllowThreads();
42670 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42671
42672 wxPyEndAllowThreads(__tstate);
42673 if (PyErr_Occurred()) SWIG_fail;
42674 }
42675 {
42676 resultobj = wxPyMake_wxObject(result, (bool)0);
42677 }
42678 return resultobj;
42679 fail:
42680 return NULL;
42681 }
42682
42683
42684 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42685 PyObject *resultobj = NULL;
42686 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42687 wxButton *result;
42688 PyObject * obj0 = 0 ;
42689 char *kwnames[] = {
42690 (char *) "self", NULL
42691 };
42692
42693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42695 if (SWIG_arg_fail(1)) SWIG_fail;
42696 {
42697 PyThreadState* __tstate = wxPyBeginAllowThreads();
42698 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42699
42700 wxPyEndAllowThreads(__tstate);
42701 if (PyErr_Occurred()) SWIG_fail;
42702 }
42703 {
42704 resultobj = wxPyMake_wxObject(result, (bool)0);
42705 }
42706 return resultobj;
42707 fail:
42708 return NULL;
42709 }
42710
42711
42712 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42713 PyObject *resultobj = NULL;
42714 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42715 wxButton *result;
42716 PyObject * obj0 = 0 ;
42717 char *kwnames[] = {
42718 (char *) "self", NULL
42719 };
42720
42721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42723 if (SWIG_arg_fail(1)) SWIG_fail;
42724 {
42725 PyThreadState* __tstate = wxPyBeginAllowThreads();
42726 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42727
42728 wxPyEndAllowThreads(__tstate);
42729 if (PyErr_Occurred()) SWIG_fail;
42730 }
42731 {
42732 resultobj = wxPyMake_wxObject(result, (bool)0);
42733 }
42734 return resultobj;
42735 fail:
42736 return NULL;
42737 }
42738
42739
42740 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42741 PyObject *obj;
42742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42743 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42744 Py_INCREF(obj);
42745 return Py_BuildValue((char *)"");
42746 }
42747 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42748 PyObject *resultobj = NULL;
42749 int arg1 = (int) 0 ;
42750 int arg2 = (int) 0 ;
42751 wxGBPosition *result;
42752 PyObject * obj0 = 0 ;
42753 PyObject * obj1 = 0 ;
42754 char *kwnames[] = {
42755 (char *) "row",(char *) "col", NULL
42756 };
42757
42758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42759 if (obj0) {
42760 {
42761 arg1 = static_cast<int >(SWIG_As_int(obj0));
42762 if (SWIG_arg_fail(1)) SWIG_fail;
42763 }
42764 }
42765 if (obj1) {
42766 {
42767 arg2 = static_cast<int >(SWIG_As_int(obj1));
42768 if (SWIG_arg_fail(2)) SWIG_fail;
42769 }
42770 }
42771 {
42772 PyThreadState* __tstate = wxPyBeginAllowThreads();
42773 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42774
42775 wxPyEndAllowThreads(__tstate);
42776 if (PyErr_Occurred()) SWIG_fail;
42777 }
42778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42779 return resultobj;
42780 fail:
42781 return NULL;
42782 }
42783
42784
42785 static PyObject *_wrap_delete_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42786 PyObject *resultobj = NULL;
42787 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42788 PyObject * obj0 = 0 ;
42789 char *kwnames[] = {
42790 (char *) "self", NULL
42791 };
42792
42793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBPosition",kwnames,&obj0)) goto fail;
42794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42795 if (SWIG_arg_fail(1)) SWIG_fail;
42796 {
42797 PyThreadState* __tstate = wxPyBeginAllowThreads();
42798 delete arg1;
42799
42800 wxPyEndAllowThreads(__tstate);
42801 if (PyErr_Occurred()) SWIG_fail;
42802 }
42803 Py_INCREF(Py_None); resultobj = Py_None;
42804 return resultobj;
42805 fail:
42806 return NULL;
42807 }
42808
42809
42810 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42811 PyObject *resultobj = NULL;
42812 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42813 int result;
42814 PyObject * obj0 = 0 ;
42815 char *kwnames[] = {
42816 (char *) "self", NULL
42817 };
42818
42819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42821 if (SWIG_arg_fail(1)) SWIG_fail;
42822 {
42823 PyThreadState* __tstate = wxPyBeginAllowThreads();
42824 result = (int)((wxGBPosition const *)arg1)->GetRow();
42825
42826 wxPyEndAllowThreads(__tstate);
42827 if (PyErr_Occurred()) SWIG_fail;
42828 }
42829 {
42830 resultobj = SWIG_From_int(static_cast<int >(result));
42831 }
42832 return resultobj;
42833 fail:
42834 return NULL;
42835 }
42836
42837
42838 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42839 PyObject *resultobj = NULL;
42840 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42841 int result;
42842 PyObject * obj0 = 0 ;
42843 char *kwnames[] = {
42844 (char *) "self", NULL
42845 };
42846
42847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42849 if (SWIG_arg_fail(1)) SWIG_fail;
42850 {
42851 PyThreadState* __tstate = wxPyBeginAllowThreads();
42852 result = (int)((wxGBPosition const *)arg1)->GetCol();
42853
42854 wxPyEndAllowThreads(__tstate);
42855 if (PyErr_Occurred()) SWIG_fail;
42856 }
42857 {
42858 resultobj = SWIG_From_int(static_cast<int >(result));
42859 }
42860 return resultobj;
42861 fail:
42862 return NULL;
42863 }
42864
42865
42866 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42867 PyObject *resultobj = NULL;
42868 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42869 int arg2 ;
42870 PyObject * obj0 = 0 ;
42871 PyObject * obj1 = 0 ;
42872 char *kwnames[] = {
42873 (char *) "self",(char *) "row", NULL
42874 };
42875
42876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42878 if (SWIG_arg_fail(1)) SWIG_fail;
42879 {
42880 arg2 = static_cast<int >(SWIG_As_int(obj1));
42881 if (SWIG_arg_fail(2)) SWIG_fail;
42882 }
42883 {
42884 PyThreadState* __tstate = wxPyBeginAllowThreads();
42885 (arg1)->SetRow(arg2);
42886
42887 wxPyEndAllowThreads(__tstate);
42888 if (PyErr_Occurred()) SWIG_fail;
42889 }
42890 Py_INCREF(Py_None); resultobj = Py_None;
42891 return resultobj;
42892 fail:
42893 return NULL;
42894 }
42895
42896
42897 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42898 PyObject *resultobj = NULL;
42899 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42900 int arg2 ;
42901 PyObject * obj0 = 0 ;
42902 PyObject * obj1 = 0 ;
42903 char *kwnames[] = {
42904 (char *) "self",(char *) "col", NULL
42905 };
42906
42907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42909 if (SWIG_arg_fail(1)) SWIG_fail;
42910 {
42911 arg2 = static_cast<int >(SWIG_As_int(obj1));
42912 if (SWIG_arg_fail(2)) SWIG_fail;
42913 }
42914 {
42915 PyThreadState* __tstate = wxPyBeginAllowThreads();
42916 (arg1)->SetCol(arg2);
42917
42918 wxPyEndAllowThreads(__tstate);
42919 if (PyErr_Occurred()) SWIG_fail;
42920 }
42921 Py_INCREF(Py_None); resultobj = Py_None;
42922 return resultobj;
42923 fail:
42924 return NULL;
42925 }
42926
42927
42928 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42929 PyObject *resultobj = NULL;
42930 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42931 wxGBPosition *arg2 = 0 ;
42932 bool result;
42933 wxGBPosition temp2 ;
42934 PyObject * obj0 = 0 ;
42935 PyObject * obj1 = 0 ;
42936 char *kwnames[] = {
42937 (char *) "self",(char *) "other", NULL
42938 };
42939
42940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42942 if (SWIG_arg_fail(1)) SWIG_fail;
42943 {
42944 arg2 = &temp2;
42945 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42946 }
42947 {
42948 PyThreadState* __tstate = wxPyBeginAllowThreads();
42949 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42950
42951 wxPyEndAllowThreads(__tstate);
42952 if (PyErr_Occurred()) SWIG_fail;
42953 }
42954 {
42955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42956 }
42957 return resultobj;
42958 fail:
42959 return NULL;
42960 }
42961
42962
42963 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42964 PyObject *resultobj = NULL;
42965 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42966 wxGBPosition *arg2 = 0 ;
42967 bool result;
42968 wxGBPosition temp2 ;
42969 PyObject * obj0 = 0 ;
42970 PyObject * obj1 = 0 ;
42971 char *kwnames[] = {
42972 (char *) "self",(char *) "other", NULL
42973 };
42974
42975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42977 if (SWIG_arg_fail(1)) SWIG_fail;
42978 {
42979 arg2 = &temp2;
42980 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42981 }
42982 {
42983 PyThreadState* __tstate = wxPyBeginAllowThreads();
42984 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42985
42986 wxPyEndAllowThreads(__tstate);
42987 if (PyErr_Occurred()) SWIG_fail;
42988 }
42989 {
42990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42991 }
42992 return resultobj;
42993 fail:
42994 return NULL;
42995 }
42996
42997
42998 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42999 PyObject *resultobj = NULL;
43000 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43001 int arg2 = (int) 0 ;
43002 int arg3 = (int) 0 ;
43003 PyObject * obj0 = 0 ;
43004 PyObject * obj1 = 0 ;
43005 PyObject * obj2 = 0 ;
43006 char *kwnames[] = {
43007 (char *) "self",(char *) "row",(char *) "col", NULL
43008 };
43009
43010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43012 if (SWIG_arg_fail(1)) SWIG_fail;
43013 if (obj1) {
43014 {
43015 arg2 = static_cast<int >(SWIG_As_int(obj1));
43016 if (SWIG_arg_fail(2)) SWIG_fail;
43017 }
43018 }
43019 if (obj2) {
43020 {
43021 arg3 = static_cast<int >(SWIG_As_int(obj2));
43022 if (SWIG_arg_fail(3)) SWIG_fail;
43023 }
43024 }
43025 {
43026 PyThreadState* __tstate = wxPyBeginAllowThreads();
43027 wxGBPosition_Set(arg1,arg2,arg3);
43028
43029 wxPyEndAllowThreads(__tstate);
43030 if (PyErr_Occurred()) SWIG_fail;
43031 }
43032 Py_INCREF(Py_None); resultobj = Py_None;
43033 return resultobj;
43034 fail:
43035 return NULL;
43036 }
43037
43038
43039 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43040 PyObject *resultobj = NULL;
43041 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43042 PyObject *result;
43043 PyObject * obj0 = 0 ;
43044 char *kwnames[] = {
43045 (char *) "self", NULL
43046 };
43047
43048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
43049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43050 if (SWIG_arg_fail(1)) SWIG_fail;
43051 {
43052 PyThreadState* __tstate = wxPyBeginAllowThreads();
43053 result = (PyObject *)wxGBPosition_Get(arg1);
43054
43055 wxPyEndAllowThreads(__tstate);
43056 if (PyErr_Occurred()) SWIG_fail;
43057 }
43058 resultobj = result;
43059 return resultobj;
43060 fail:
43061 return NULL;
43062 }
43063
43064
43065 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
43066 PyObject *obj;
43067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43068 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
43069 Py_INCREF(obj);
43070 return Py_BuildValue((char *)"");
43071 }
43072 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43073 PyObject *resultobj = NULL;
43074 int arg1 = (int) 1 ;
43075 int arg2 = (int) 1 ;
43076 wxGBSpan *result;
43077 PyObject * obj0 = 0 ;
43078 PyObject * obj1 = 0 ;
43079 char *kwnames[] = {
43080 (char *) "rowspan",(char *) "colspan", NULL
43081 };
43082
43083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
43084 if (obj0) {
43085 {
43086 arg1 = static_cast<int >(SWIG_As_int(obj0));
43087 if (SWIG_arg_fail(1)) SWIG_fail;
43088 }
43089 }
43090 if (obj1) {
43091 {
43092 arg2 = static_cast<int >(SWIG_As_int(obj1));
43093 if (SWIG_arg_fail(2)) SWIG_fail;
43094 }
43095 }
43096 {
43097 PyThreadState* __tstate = wxPyBeginAllowThreads();
43098 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
43099
43100 wxPyEndAllowThreads(__tstate);
43101 if (PyErr_Occurred()) SWIG_fail;
43102 }
43103 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
43104 return resultobj;
43105 fail:
43106 return NULL;
43107 }
43108
43109
43110 static PyObject *_wrap_delete_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43111 PyObject *resultobj = NULL;
43112 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43113 PyObject * obj0 = 0 ;
43114 char *kwnames[] = {
43115 (char *) "self", NULL
43116 };
43117
43118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSpan",kwnames,&obj0)) goto fail;
43119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43120 if (SWIG_arg_fail(1)) SWIG_fail;
43121 {
43122 PyThreadState* __tstate = wxPyBeginAllowThreads();
43123 delete arg1;
43124
43125 wxPyEndAllowThreads(__tstate);
43126 if (PyErr_Occurred()) SWIG_fail;
43127 }
43128 Py_INCREF(Py_None); resultobj = Py_None;
43129 return resultobj;
43130 fail:
43131 return NULL;
43132 }
43133
43134
43135 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43136 PyObject *resultobj = NULL;
43137 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43138 int result;
43139 PyObject * obj0 = 0 ;
43140 char *kwnames[] = {
43141 (char *) "self", NULL
43142 };
43143
43144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
43145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43146 if (SWIG_arg_fail(1)) SWIG_fail;
43147 {
43148 PyThreadState* __tstate = wxPyBeginAllowThreads();
43149 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
43150
43151 wxPyEndAllowThreads(__tstate);
43152 if (PyErr_Occurred()) SWIG_fail;
43153 }
43154 {
43155 resultobj = SWIG_From_int(static_cast<int >(result));
43156 }
43157 return resultobj;
43158 fail:
43159 return NULL;
43160 }
43161
43162
43163 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43164 PyObject *resultobj = NULL;
43165 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43166 int result;
43167 PyObject * obj0 = 0 ;
43168 char *kwnames[] = {
43169 (char *) "self", NULL
43170 };
43171
43172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43174 if (SWIG_arg_fail(1)) SWIG_fail;
43175 {
43176 PyThreadState* __tstate = wxPyBeginAllowThreads();
43177 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43178
43179 wxPyEndAllowThreads(__tstate);
43180 if (PyErr_Occurred()) SWIG_fail;
43181 }
43182 {
43183 resultobj = SWIG_From_int(static_cast<int >(result));
43184 }
43185 return resultobj;
43186 fail:
43187 return NULL;
43188 }
43189
43190
43191 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43192 PyObject *resultobj = NULL;
43193 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43194 int arg2 ;
43195 PyObject * obj0 = 0 ;
43196 PyObject * obj1 = 0 ;
43197 char *kwnames[] = {
43198 (char *) "self",(char *) "rowspan", NULL
43199 };
43200
43201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43203 if (SWIG_arg_fail(1)) SWIG_fail;
43204 {
43205 arg2 = static_cast<int >(SWIG_As_int(obj1));
43206 if (SWIG_arg_fail(2)) SWIG_fail;
43207 }
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 (arg1)->SetRowspan(arg2);
43211
43212 wxPyEndAllowThreads(__tstate);
43213 if (PyErr_Occurred()) SWIG_fail;
43214 }
43215 Py_INCREF(Py_None); resultobj = Py_None;
43216 return resultobj;
43217 fail:
43218 return NULL;
43219 }
43220
43221
43222 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43223 PyObject *resultobj = NULL;
43224 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43225 int arg2 ;
43226 PyObject * obj0 = 0 ;
43227 PyObject * obj1 = 0 ;
43228 char *kwnames[] = {
43229 (char *) "self",(char *) "colspan", NULL
43230 };
43231
43232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43234 if (SWIG_arg_fail(1)) SWIG_fail;
43235 {
43236 arg2 = static_cast<int >(SWIG_As_int(obj1));
43237 if (SWIG_arg_fail(2)) SWIG_fail;
43238 }
43239 {
43240 PyThreadState* __tstate = wxPyBeginAllowThreads();
43241 (arg1)->SetColspan(arg2);
43242
43243 wxPyEndAllowThreads(__tstate);
43244 if (PyErr_Occurred()) SWIG_fail;
43245 }
43246 Py_INCREF(Py_None); resultobj = Py_None;
43247 return resultobj;
43248 fail:
43249 return NULL;
43250 }
43251
43252
43253 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43254 PyObject *resultobj = NULL;
43255 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43256 wxGBSpan *arg2 = 0 ;
43257 bool result;
43258 wxGBSpan temp2 ;
43259 PyObject * obj0 = 0 ;
43260 PyObject * obj1 = 0 ;
43261 char *kwnames[] = {
43262 (char *) "self",(char *) "other", NULL
43263 };
43264
43265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43267 if (SWIG_arg_fail(1)) SWIG_fail;
43268 {
43269 arg2 = &temp2;
43270 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43271 }
43272 {
43273 PyThreadState* __tstate = wxPyBeginAllowThreads();
43274 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43275
43276 wxPyEndAllowThreads(__tstate);
43277 if (PyErr_Occurred()) SWIG_fail;
43278 }
43279 {
43280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43281 }
43282 return resultobj;
43283 fail:
43284 return NULL;
43285 }
43286
43287
43288 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43289 PyObject *resultobj = NULL;
43290 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43291 wxGBSpan *arg2 = 0 ;
43292 bool result;
43293 wxGBSpan temp2 ;
43294 PyObject * obj0 = 0 ;
43295 PyObject * obj1 = 0 ;
43296 char *kwnames[] = {
43297 (char *) "self",(char *) "other", NULL
43298 };
43299
43300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43302 if (SWIG_arg_fail(1)) SWIG_fail;
43303 {
43304 arg2 = &temp2;
43305 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43306 }
43307 {
43308 PyThreadState* __tstate = wxPyBeginAllowThreads();
43309 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43310
43311 wxPyEndAllowThreads(__tstate);
43312 if (PyErr_Occurred()) SWIG_fail;
43313 }
43314 {
43315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43316 }
43317 return resultobj;
43318 fail:
43319 return NULL;
43320 }
43321
43322
43323 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43324 PyObject *resultobj = NULL;
43325 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43326 int arg2 = (int) 1 ;
43327 int arg3 = (int) 1 ;
43328 PyObject * obj0 = 0 ;
43329 PyObject * obj1 = 0 ;
43330 PyObject * obj2 = 0 ;
43331 char *kwnames[] = {
43332 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43333 };
43334
43335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43337 if (SWIG_arg_fail(1)) SWIG_fail;
43338 if (obj1) {
43339 {
43340 arg2 = static_cast<int >(SWIG_As_int(obj1));
43341 if (SWIG_arg_fail(2)) SWIG_fail;
43342 }
43343 }
43344 if (obj2) {
43345 {
43346 arg3 = static_cast<int >(SWIG_As_int(obj2));
43347 if (SWIG_arg_fail(3)) SWIG_fail;
43348 }
43349 }
43350 {
43351 PyThreadState* __tstate = wxPyBeginAllowThreads();
43352 wxGBSpan_Set(arg1,arg2,arg3);
43353
43354 wxPyEndAllowThreads(__tstate);
43355 if (PyErr_Occurred()) SWIG_fail;
43356 }
43357 Py_INCREF(Py_None); resultobj = Py_None;
43358 return resultobj;
43359 fail:
43360 return NULL;
43361 }
43362
43363
43364 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43365 PyObject *resultobj = NULL;
43366 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43367 PyObject *result;
43368 PyObject * obj0 = 0 ;
43369 char *kwnames[] = {
43370 (char *) "self", NULL
43371 };
43372
43373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43375 if (SWIG_arg_fail(1)) SWIG_fail;
43376 {
43377 PyThreadState* __tstate = wxPyBeginAllowThreads();
43378 result = (PyObject *)wxGBSpan_Get(arg1);
43379
43380 wxPyEndAllowThreads(__tstate);
43381 if (PyErr_Occurred()) SWIG_fail;
43382 }
43383 resultobj = result;
43384 return resultobj;
43385 fail:
43386 return NULL;
43387 }
43388
43389
43390 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43391 PyObject *obj;
43392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43393 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43394 Py_INCREF(obj);
43395 return Py_BuildValue((char *)"");
43396 }
43397 static int _wrap_DefaultSpan_set(PyObject *) {
43398 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43399 return 1;
43400 }
43401
43402
43403 static PyObject *_wrap_DefaultSpan_get(void) {
43404 PyObject *pyobj = NULL;
43405
43406 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43407 return pyobj;
43408 }
43409
43410
43411 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43412 PyObject *resultobj = NULL;
43413 wxGBSizerItem *result;
43414 char *kwnames[] = {
43415 NULL
43416 };
43417
43418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43419 {
43420 PyThreadState* __tstate = wxPyBeginAllowThreads();
43421 result = (wxGBSizerItem *)new wxGBSizerItem();
43422
43423 wxPyEndAllowThreads(__tstate);
43424 if (PyErr_Occurred()) SWIG_fail;
43425 }
43426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43427 return resultobj;
43428 fail:
43429 return NULL;
43430 }
43431
43432
43433 static PyObject *_wrap_delete_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43434 PyObject *resultobj = NULL;
43435 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43436 PyObject * obj0 = 0 ;
43437 char *kwnames[] = {
43438 (char *) "self", NULL
43439 };
43440
43441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSizerItem",kwnames,&obj0)) goto fail;
43442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43443 if (SWIG_arg_fail(1)) SWIG_fail;
43444 {
43445 PyThreadState* __tstate = wxPyBeginAllowThreads();
43446 delete arg1;
43447
43448 wxPyEndAllowThreads(__tstate);
43449 if (PyErr_Occurred()) SWIG_fail;
43450 }
43451 Py_INCREF(Py_None); resultobj = Py_None;
43452 return resultobj;
43453 fail:
43454 return NULL;
43455 }
43456
43457
43458 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43459 PyObject *resultobj = NULL;
43460 wxWindow *arg1 = (wxWindow *) 0 ;
43461 wxGBPosition *arg2 = 0 ;
43462 wxGBSpan *arg3 = 0 ;
43463 int arg4 ;
43464 int arg5 ;
43465 PyObject *arg6 = (PyObject *) NULL ;
43466 wxGBSizerItem *result;
43467 wxGBPosition temp2 ;
43468 wxGBSpan temp3 ;
43469 PyObject * obj0 = 0 ;
43470 PyObject * obj1 = 0 ;
43471 PyObject * obj2 = 0 ;
43472 PyObject * obj3 = 0 ;
43473 PyObject * obj4 = 0 ;
43474 PyObject * obj5 = 0 ;
43475 char *kwnames[] = {
43476 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43477 };
43478
43479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43481 if (SWIG_arg_fail(1)) SWIG_fail;
43482 {
43483 arg2 = &temp2;
43484 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43485 }
43486 {
43487 arg3 = &temp3;
43488 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43489 }
43490 {
43491 arg4 = static_cast<int >(SWIG_As_int(obj3));
43492 if (SWIG_arg_fail(4)) SWIG_fail;
43493 }
43494 {
43495 arg5 = static_cast<int >(SWIG_As_int(obj4));
43496 if (SWIG_arg_fail(5)) SWIG_fail;
43497 }
43498 if (obj5) {
43499 arg6 = obj5;
43500 }
43501 {
43502 PyThreadState* __tstate = wxPyBeginAllowThreads();
43503 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43504
43505 wxPyEndAllowThreads(__tstate);
43506 if (PyErr_Occurred()) SWIG_fail;
43507 }
43508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43509 return resultobj;
43510 fail:
43511 return NULL;
43512 }
43513
43514
43515 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43516 PyObject *resultobj = NULL;
43517 wxSizer *arg1 = (wxSizer *) 0 ;
43518 wxGBPosition *arg2 = 0 ;
43519 wxGBSpan *arg3 = 0 ;
43520 int arg4 ;
43521 int arg5 ;
43522 PyObject *arg6 = (PyObject *) NULL ;
43523 wxGBSizerItem *result;
43524 wxGBPosition temp2 ;
43525 wxGBSpan temp3 ;
43526 PyObject * obj0 = 0 ;
43527 PyObject * obj1 = 0 ;
43528 PyObject * obj2 = 0 ;
43529 PyObject * obj3 = 0 ;
43530 PyObject * obj4 = 0 ;
43531 PyObject * obj5 = 0 ;
43532 char *kwnames[] = {
43533 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43534 };
43535
43536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
43538 if (SWIG_arg_fail(1)) SWIG_fail;
43539 {
43540 arg2 = &temp2;
43541 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43542 }
43543 {
43544 arg3 = &temp3;
43545 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43546 }
43547 {
43548 arg4 = static_cast<int >(SWIG_As_int(obj3));
43549 if (SWIG_arg_fail(4)) SWIG_fail;
43550 }
43551 {
43552 arg5 = static_cast<int >(SWIG_As_int(obj4));
43553 if (SWIG_arg_fail(5)) SWIG_fail;
43554 }
43555 if (obj5) {
43556 arg6 = obj5;
43557 }
43558 {
43559 PyThreadState* __tstate = wxPyBeginAllowThreads();
43560 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43561
43562 wxPyEndAllowThreads(__tstate);
43563 if (PyErr_Occurred()) SWIG_fail;
43564 }
43565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43566 return resultobj;
43567 fail:
43568 return NULL;
43569 }
43570
43571
43572 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43573 PyObject *resultobj = NULL;
43574 int arg1 ;
43575 int arg2 ;
43576 wxGBPosition *arg3 = 0 ;
43577 wxGBSpan *arg4 = 0 ;
43578 int arg5 ;
43579 int arg6 ;
43580 PyObject *arg7 = (PyObject *) NULL ;
43581 wxGBSizerItem *result;
43582 wxGBPosition temp3 ;
43583 wxGBSpan temp4 ;
43584 PyObject * obj0 = 0 ;
43585 PyObject * obj1 = 0 ;
43586 PyObject * obj2 = 0 ;
43587 PyObject * obj3 = 0 ;
43588 PyObject * obj4 = 0 ;
43589 PyObject * obj5 = 0 ;
43590 PyObject * obj6 = 0 ;
43591 char *kwnames[] = {
43592 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43593 };
43594
43595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43596 {
43597 arg1 = static_cast<int >(SWIG_As_int(obj0));
43598 if (SWIG_arg_fail(1)) SWIG_fail;
43599 }
43600 {
43601 arg2 = static_cast<int >(SWIG_As_int(obj1));
43602 if (SWIG_arg_fail(2)) SWIG_fail;
43603 }
43604 {
43605 arg3 = &temp3;
43606 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43607 }
43608 {
43609 arg4 = &temp4;
43610 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43611 }
43612 {
43613 arg5 = static_cast<int >(SWIG_As_int(obj4));
43614 if (SWIG_arg_fail(5)) SWIG_fail;
43615 }
43616 {
43617 arg6 = static_cast<int >(SWIG_As_int(obj5));
43618 if (SWIG_arg_fail(6)) SWIG_fail;
43619 }
43620 if (obj6) {
43621 arg7 = obj6;
43622 }
43623 {
43624 PyThreadState* __tstate = wxPyBeginAllowThreads();
43625 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43626
43627 wxPyEndAllowThreads(__tstate);
43628 if (PyErr_Occurred()) SWIG_fail;
43629 }
43630 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43631 return resultobj;
43632 fail:
43633 return NULL;
43634 }
43635
43636
43637 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43638 PyObject *resultobj = NULL;
43639 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43640 wxGBPosition result;
43641 PyObject * obj0 = 0 ;
43642 char *kwnames[] = {
43643 (char *) "self", NULL
43644 };
43645
43646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43648 if (SWIG_arg_fail(1)) SWIG_fail;
43649 {
43650 PyThreadState* __tstate = wxPyBeginAllowThreads();
43651 result = ((wxGBSizerItem const *)arg1)->GetPos();
43652
43653 wxPyEndAllowThreads(__tstate);
43654 if (PyErr_Occurred()) SWIG_fail;
43655 }
43656 {
43657 wxGBPosition * resultptr;
43658 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43659 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43660 }
43661 return resultobj;
43662 fail:
43663 return NULL;
43664 }
43665
43666
43667 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43668 PyObject *resultobj = NULL;
43669 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43670 wxGBSpan result;
43671 PyObject * obj0 = 0 ;
43672 char *kwnames[] = {
43673 (char *) "self", NULL
43674 };
43675
43676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43678 if (SWIG_arg_fail(1)) SWIG_fail;
43679 {
43680 PyThreadState* __tstate = wxPyBeginAllowThreads();
43681 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43682
43683 wxPyEndAllowThreads(__tstate);
43684 if (PyErr_Occurred()) SWIG_fail;
43685 }
43686 {
43687 wxGBSpan * resultptr;
43688 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43689 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43690 }
43691 return resultobj;
43692 fail:
43693 return NULL;
43694 }
43695
43696
43697 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43698 PyObject *resultobj = NULL;
43699 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43700 wxGBPosition *arg2 = 0 ;
43701 bool result;
43702 wxGBPosition temp2 ;
43703 PyObject * obj0 = 0 ;
43704 PyObject * obj1 = 0 ;
43705 char *kwnames[] = {
43706 (char *) "self",(char *) "pos", NULL
43707 };
43708
43709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43711 if (SWIG_arg_fail(1)) SWIG_fail;
43712 {
43713 arg2 = &temp2;
43714 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43715 }
43716 {
43717 PyThreadState* __tstate = wxPyBeginAllowThreads();
43718 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43719
43720 wxPyEndAllowThreads(__tstate);
43721 if (PyErr_Occurred()) SWIG_fail;
43722 }
43723 {
43724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43725 }
43726 return resultobj;
43727 fail:
43728 return NULL;
43729 }
43730
43731
43732 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43733 PyObject *resultobj = NULL;
43734 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43735 wxGBSpan *arg2 = 0 ;
43736 bool result;
43737 wxGBSpan temp2 ;
43738 PyObject * obj0 = 0 ;
43739 PyObject * obj1 = 0 ;
43740 char *kwnames[] = {
43741 (char *) "self",(char *) "span", NULL
43742 };
43743
43744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43746 if (SWIG_arg_fail(1)) SWIG_fail;
43747 {
43748 arg2 = &temp2;
43749 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43750 }
43751 {
43752 PyThreadState* __tstate = wxPyBeginAllowThreads();
43753 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43754
43755 wxPyEndAllowThreads(__tstate);
43756 if (PyErr_Occurred()) SWIG_fail;
43757 }
43758 {
43759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43760 }
43761 return resultobj;
43762 fail:
43763 return NULL;
43764 }
43765
43766
43767 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43768 PyObject *resultobj = NULL;
43769 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43770 wxGBSizerItem *arg2 = 0 ;
43771 bool result;
43772 PyObject * obj0 = 0 ;
43773 PyObject * obj1 = 0 ;
43774 char *kwnames[] = {
43775 (char *) "self",(char *) "other", NULL
43776 };
43777
43778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43780 if (SWIG_arg_fail(1)) SWIG_fail;
43781 {
43782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43783 if (SWIG_arg_fail(2)) SWIG_fail;
43784 if (arg2 == NULL) {
43785 SWIG_null_ref("wxGBSizerItem");
43786 }
43787 if (SWIG_arg_fail(2)) SWIG_fail;
43788 }
43789 {
43790 PyThreadState* __tstate = wxPyBeginAllowThreads();
43791 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43792
43793 wxPyEndAllowThreads(__tstate);
43794 if (PyErr_Occurred()) SWIG_fail;
43795 }
43796 {
43797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43798 }
43799 return resultobj;
43800 fail:
43801 return NULL;
43802 }
43803
43804
43805 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43806 PyObject *resultobj = NULL;
43807 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43808 wxGBPosition *arg2 = 0 ;
43809 wxGBSpan *arg3 = 0 ;
43810 bool result;
43811 wxGBPosition temp2 ;
43812 wxGBSpan temp3 ;
43813 PyObject * obj0 = 0 ;
43814 PyObject * obj1 = 0 ;
43815 PyObject * obj2 = 0 ;
43816 char *kwnames[] = {
43817 (char *) "self",(char *) "pos",(char *) "span", NULL
43818 };
43819
43820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43822 if (SWIG_arg_fail(1)) SWIG_fail;
43823 {
43824 arg2 = &temp2;
43825 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43826 }
43827 {
43828 arg3 = &temp3;
43829 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43830 }
43831 {
43832 PyThreadState* __tstate = wxPyBeginAllowThreads();
43833 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43834
43835 wxPyEndAllowThreads(__tstate);
43836 if (PyErr_Occurred()) SWIG_fail;
43837 }
43838 {
43839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43840 }
43841 return resultobj;
43842 fail:
43843 return NULL;
43844 }
43845
43846
43847 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43848 PyObject *resultobj = NULL;
43849 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43850 wxGBPosition result;
43851 PyObject * obj0 = 0 ;
43852 char *kwnames[] = {
43853 (char *) "self", NULL
43854 };
43855
43856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43858 if (SWIG_arg_fail(1)) SWIG_fail;
43859 {
43860 PyThreadState* __tstate = wxPyBeginAllowThreads();
43861 result = wxGBSizerItem_GetEndPos(arg1);
43862
43863 wxPyEndAllowThreads(__tstate);
43864 if (PyErr_Occurred()) SWIG_fail;
43865 }
43866 {
43867 wxGBPosition * resultptr;
43868 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43869 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43870 }
43871 return resultobj;
43872 fail:
43873 return NULL;
43874 }
43875
43876
43877 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43878 PyObject *resultobj = NULL;
43879 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43880 wxGridBagSizer *result;
43881 PyObject * obj0 = 0 ;
43882 char *kwnames[] = {
43883 (char *) "self", NULL
43884 };
43885
43886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43888 if (SWIG_arg_fail(1)) SWIG_fail;
43889 {
43890 PyThreadState* __tstate = wxPyBeginAllowThreads();
43891 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43892
43893 wxPyEndAllowThreads(__tstate);
43894 if (PyErr_Occurred()) SWIG_fail;
43895 }
43896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43897 return resultobj;
43898 fail:
43899 return NULL;
43900 }
43901
43902
43903 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43904 PyObject *resultobj = NULL;
43905 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43906 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43907 PyObject * obj0 = 0 ;
43908 PyObject * obj1 = 0 ;
43909 char *kwnames[] = {
43910 (char *) "self",(char *) "sizer", NULL
43911 };
43912
43913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43915 if (SWIG_arg_fail(1)) SWIG_fail;
43916 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43917 if (SWIG_arg_fail(2)) SWIG_fail;
43918 {
43919 PyThreadState* __tstate = wxPyBeginAllowThreads();
43920 (arg1)->SetGBSizer(arg2);
43921
43922 wxPyEndAllowThreads(__tstate);
43923 if (PyErr_Occurred()) SWIG_fail;
43924 }
43925 Py_INCREF(Py_None); resultobj = Py_None;
43926 return resultobj;
43927 fail:
43928 return NULL;
43929 }
43930
43931
43932 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43933 PyObject *obj;
43934 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43935 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43936 Py_INCREF(obj);
43937 return Py_BuildValue((char *)"");
43938 }
43939 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43940 PyObject *resultobj = NULL;
43941 int arg1 = (int) 0 ;
43942 int arg2 = (int) 0 ;
43943 wxGridBagSizer *result;
43944 PyObject * obj0 = 0 ;
43945 PyObject * obj1 = 0 ;
43946 char *kwnames[] = {
43947 (char *) "vgap",(char *) "hgap", NULL
43948 };
43949
43950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43951 if (obj0) {
43952 {
43953 arg1 = static_cast<int >(SWIG_As_int(obj0));
43954 if (SWIG_arg_fail(1)) SWIG_fail;
43955 }
43956 }
43957 if (obj1) {
43958 {
43959 arg2 = static_cast<int >(SWIG_As_int(obj1));
43960 if (SWIG_arg_fail(2)) SWIG_fail;
43961 }
43962 }
43963 {
43964 PyThreadState* __tstate = wxPyBeginAllowThreads();
43965 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43966
43967 wxPyEndAllowThreads(__tstate);
43968 if (PyErr_Occurred()) SWIG_fail;
43969 }
43970 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43971 return resultobj;
43972 fail:
43973 return NULL;
43974 }
43975
43976
43977 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43978 PyObject *resultobj = NULL;
43979 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43980 PyObject *arg2 = (PyObject *) 0 ;
43981 wxGBPosition *arg3 = 0 ;
43982 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43983 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43984 int arg5 = (int) 0 ;
43985 int arg6 = (int) 0 ;
43986 PyObject *arg7 = (PyObject *) NULL ;
43987 wxGBSizerItem *result;
43988 wxGBPosition temp3 ;
43989 wxGBSpan temp4 ;
43990 PyObject * obj0 = 0 ;
43991 PyObject * obj1 = 0 ;
43992 PyObject * obj2 = 0 ;
43993 PyObject * obj3 = 0 ;
43994 PyObject * obj4 = 0 ;
43995 PyObject * obj5 = 0 ;
43996 PyObject * obj6 = 0 ;
43997 char *kwnames[] = {
43998 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43999 };
44000
44001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
44002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44003 if (SWIG_arg_fail(1)) SWIG_fail;
44004 arg2 = obj1;
44005 {
44006 arg3 = &temp3;
44007 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44008 }
44009 if (obj3) {
44010 {
44011 arg4 = &temp4;
44012 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
44013 }
44014 }
44015 if (obj4) {
44016 {
44017 arg5 = static_cast<int >(SWIG_As_int(obj4));
44018 if (SWIG_arg_fail(5)) SWIG_fail;
44019 }
44020 }
44021 if (obj5) {
44022 {
44023 arg6 = static_cast<int >(SWIG_As_int(obj5));
44024 if (SWIG_arg_fail(6)) SWIG_fail;
44025 }
44026 }
44027 if (obj6) {
44028 arg7 = obj6;
44029 }
44030 {
44031 PyThreadState* __tstate = wxPyBeginAllowThreads();
44032 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
44033
44034 wxPyEndAllowThreads(__tstate);
44035 if (PyErr_Occurred()) SWIG_fail;
44036 }
44037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44038 return resultobj;
44039 fail:
44040 return NULL;
44041 }
44042
44043
44044 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
44045 PyObject *resultobj = NULL;
44046 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44047 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44048 wxGBSizerItem *result;
44049 PyObject * obj0 = 0 ;
44050 PyObject * obj1 = 0 ;
44051 char *kwnames[] = {
44052 (char *) "self",(char *) "item", NULL
44053 };
44054
44055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
44056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44057 if (SWIG_arg_fail(1)) SWIG_fail;
44058 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
44059 if (SWIG_arg_fail(2)) SWIG_fail;
44060 {
44061 PyThreadState* __tstate = wxPyBeginAllowThreads();
44062 result = (wxGBSizerItem *)(arg1)->Add(arg2);
44063
44064 wxPyEndAllowThreads(__tstate);
44065 if (PyErr_Occurred()) SWIG_fail;
44066 }
44067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44068 return resultobj;
44069 fail:
44070 return NULL;
44071 }
44072
44073
44074 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44075 PyObject *resultobj = NULL;
44076 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44077 int arg2 ;
44078 int arg3 ;
44079 wxSize result;
44080 PyObject * obj0 = 0 ;
44081 PyObject * obj1 = 0 ;
44082 PyObject * obj2 = 0 ;
44083 char *kwnames[] = {
44084 (char *) "self",(char *) "row",(char *) "col", NULL
44085 };
44086
44087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
44088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44089 if (SWIG_arg_fail(1)) SWIG_fail;
44090 {
44091 arg2 = static_cast<int >(SWIG_As_int(obj1));
44092 if (SWIG_arg_fail(2)) SWIG_fail;
44093 }
44094 {
44095 arg3 = static_cast<int >(SWIG_As_int(obj2));
44096 if (SWIG_arg_fail(3)) SWIG_fail;
44097 }
44098 {
44099 PyThreadState* __tstate = wxPyBeginAllowThreads();
44100 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
44101
44102 wxPyEndAllowThreads(__tstate);
44103 if (PyErr_Occurred()) SWIG_fail;
44104 }
44105 {
44106 wxSize * resultptr;
44107 resultptr = new wxSize(static_cast<wxSize & >(result));
44108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44109 }
44110 return resultobj;
44111 fail:
44112 return NULL;
44113 }
44114
44115
44116 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44117 PyObject *resultobj = NULL;
44118 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44119 wxSize result;
44120 PyObject * obj0 = 0 ;
44121 char *kwnames[] = {
44122 (char *) "self", NULL
44123 };
44124
44125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
44126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44127 if (SWIG_arg_fail(1)) SWIG_fail;
44128 {
44129 PyThreadState* __tstate = wxPyBeginAllowThreads();
44130 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
44131
44132 wxPyEndAllowThreads(__tstate);
44133 if (PyErr_Occurred()) SWIG_fail;
44134 }
44135 {
44136 wxSize * resultptr;
44137 resultptr = new wxSize(static_cast<wxSize & >(result));
44138 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44139 }
44140 return resultobj;
44141 fail:
44142 return NULL;
44143 }
44144
44145
44146 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44147 PyObject *resultobj = NULL;
44148 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44149 wxSize *arg2 = 0 ;
44150 wxSize temp2 ;
44151 PyObject * obj0 = 0 ;
44152 PyObject * obj1 = 0 ;
44153 char *kwnames[] = {
44154 (char *) "self",(char *) "sz", NULL
44155 };
44156
44157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
44158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44159 if (SWIG_arg_fail(1)) SWIG_fail;
44160 {
44161 arg2 = &temp2;
44162 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44163 }
44164 {
44165 PyThreadState* __tstate = wxPyBeginAllowThreads();
44166 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
44167
44168 wxPyEndAllowThreads(__tstate);
44169 if (PyErr_Occurred()) SWIG_fail;
44170 }
44171 Py_INCREF(Py_None); resultobj = Py_None;
44172 return resultobj;
44173 fail:
44174 return NULL;
44175 }
44176
44177
44178 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44179 PyObject *resultobj = NULL;
44180 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44181 wxWindow *arg2 = (wxWindow *) 0 ;
44182 wxGBPosition result;
44183 PyObject * obj0 = 0 ;
44184 PyObject * obj1 = 0 ;
44185
44186 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44190 if (SWIG_arg_fail(2)) SWIG_fail;
44191 {
44192 PyThreadState* __tstate = wxPyBeginAllowThreads();
44193 result = (arg1)->GetItemPosition(arg2);
44194
44195 wxPyEndAllowThreads(__tstate);
44196 if (PyErr_Occurred()) SWIG_fail;
44197 }
44198 {
44199 wxGBPosition * resultptr;
44200 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44202 }
44203 return resultobj;
44204 fail:
44205 return NULL;
44206 }
44207
44208
44209 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44210 PyObject *resultobj = NULL;
44211 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44212 wxSizer *arg2 = (wxSizer *) 0 ;
44213 wxGBPosition result;
44214 PyObject * obj0 = 0 ;
44215 PyObject * obj1 = 0 ;
44216
44217 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44219 if (SWIG_arg_fail(1)) SWIG_fail;
44220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44221 if (SWIG_arg_fail(2)) SWIG_fail;
44222 {
44223 PyThreadState* __tstate = wxPyBeginAllowThreads();
44224 result = (arg1)->GetItemPosition(arg2);
44225
44226 wxPyEndAllowThreads(__tstate);
44227 if (PyErr_Occurred()) SWIG_fail;
44228 }
44229 {
44230 wxGBPosition * resultptr;
44231 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44232 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44233 }
44234 return resultobj;
44235 fail:
44236 return NULL;
44237 }
44238
44239
44240 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44241 PyObject *resultobj = NULL;
44242 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44243 size_t arg2 ;
44244 wxGBPosition result;
44245 PyObject * obj0 = 0 ;
44246 PyObject * obj1 = 0 ;
44247
44248 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44250 if (SWIG_arg_fail(1)) SWIG_fail;
44251 {
44252 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44253 if (SWIG_arg_fail(2)) SWIG_fail;
44254 }
44255 {
44256 PyThreadState* __tstate = wxPyBeginAllowThreads();
44257 result = (arg1)->GetItemPosition(arg2);
44258
44259 wxPyEndAllowThreads(__tstate);
44260 if (PyErr_Occurred()) SWIG_fail;
44261 }
44262 {
44263 wxGBPosition * resultptr;
44264 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44265 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44266 }
44267 return resultobj;
44268 fail:
44269 return NULL;
44270 }
44271
44272
44273 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44274 int argc;
44275 PyObject *argv[3];
44276 int ii;
44277
44278 argc = PyObject_Length(args);
44279 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44280 argv[ii] = PyTuple_GetItem(args,ii);
44281 }
44282 if (argc == 2) {
44283 int _v;
44284 {
44285 void *ptr;
44286 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44287 _v = 0;
44288 PyErr_Clear();
44289 } else {
44290 _v = 1;
44291 }
44292 }
44293 if (_v) {
44294 {
44295 void *ptr;
44296 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44297 _v = 0;
44298 PyErr_Clear();
44299 } else {
44300 _v = 1;
44301 }
44302 }
44303 if (_v) {
44304 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44305 }
44306 }
44307 }
44308 if (argc == 2) {
44309 int _v;
44310 {
44311 void *ptr;
44312 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44313 _v = 0;
44314 PyErr_Clear();
44315 } else {
44316 _v = 1;
44317 }
44318 }
44319 if (_v) {
44320 {
44321 void *ptr;
44322 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44323 _v = 0;
44324 PyErr_Clear();
44325 } else {
44326 _v = 1;
44327 }
44328 }
44329 if (_v) {
44330 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44331 }
44332 }
44333 }
44334 if (argc == 2) {
44335 int _v;
44336 {
44337 void *ptr;
44338 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44339 _v = 0;
44340 PyErr_Clear();
44341 } else {
44342 _v = 1;
44343 }
44344 }
44345 if (_v) {
44346 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44347 if (_v) {
44348 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44349 }
44350 }
44351 }
44352
44353 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44354 return NULL;
44355 }
44356
44357
44358 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44359 PyObject *resultobj = NULL;
44360 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44361 wxWindow *arg2 = (wxWindow *) 0 ;
44362 wxGBPosition *arg3 = 0 ;
44363 bool result;
44364 wxGBPosition temp3 ;
44365 PyObject * obj0 = 0 ;
44366 PyObject * obj1 = 0 ;
44367 PyObject * obj2 = 0 ;
44368
44369 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44371 if (SWIG_arg_fail(1)) SWIG_fail;
44372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44373 if (SWIG_arg_fail(2)) SWIG_fail;
44374 {
44375 arg3 = &temp3;
44376 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44377 }
44378 {
44379 PyThreadState* __tstate = wxPyBeginAllowThreads();
44380 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44381
44382 wxPyEndAllowThreads(__tstate);
44383 if (PyErr_Occurred()) SWIG_fail;
44384 }
44385 {
44386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44387 }
44388 return resultobj;
44389 fail:
44390 return NULL;
44391 }
44392
44393
44394 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44395 PyObject *resultobj = NULL;
44396 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44397 wxSizer *arg2 = (wxSizer *) 0 ;
44398 wxGBPosition *arg3 = 0 ;
44399 bool result;
44400 wxGBPosition temp3 ;
44401 PyObject * obj0 = 0 ;
44402 PyObject * obj1 = 0 ;
44403 PyObject * obj2 = 0 ;
44404
44405 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44407 if (SWIG_arg_fail(1)) SWIG_fail;
44408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44409 if (SWIG_arg_fail(2)) SWIG_fail;
44410 {
44411 arg3 = &temp3;
44412 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44413 }
44414 {
44415 PyThreadState* __tstate = wxPyBeginAllowThreads();
44416 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44417
44418 wxPyEndAllowThreads(__tstate);
44419 if (PyErr_Occurred()) SWIG_fail;
44420 }
44421 {
44422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44423 }
44424 return resultobj;
44425 fail:
44426 return NULL;
44427 }
44428
44429
44430 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44431 PyObject *resultobj = NULL;
44432 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44433 size_t arg2 ;
44434 wxGBPosition *arg3 = 0 ;
44435 bool result;
44436 wxGBPosition temp3 ;
44437 PyObject * obj0 = 0 ;
44438 PyObject * obj1 = 0 ;
44439 PyObject * obj2 = 0 ;
44440
44441 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44443 if (SWIG_arg_fail(1)) SWIG_fail;
44444 {
44445 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44446 if (SWIG_arg_fail(2)) SWIG_fail;
44447 }
44448 {
44449 arg3 = &temp3;
44450 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44451 }
44452 {
44453 PyThreadState* __tstate = wxPyBeginAllowThreads();
44454 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44455
44456 wxPyEndAllowThreads(__tstate);
44457 if (PyErr_Occurred()) SWIG_fail;
44458 }
44459 {
44460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44461 }
44462 return resultobj;
44463 fail:
44464 return NULL;
44465 }
44466
44467
44468 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44469 int argc;
44470 PyObject *argv[4];
44471 int ii;
44472
44473 argc = PyObject_Length(args);
44474 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44475 argv[ii] = PyTuple_GetItem(args,ii);
44476 }
44477 if (argc == 3) {
44478 int _v;
44479 {
44480 void *ptr;
44481 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44482 _v = 0;
44483 PyErr_Clear();
44484 } else {
44485 _v = 1;
44486 }
44487 }
44488 if (_v) {
44489 {
44490 void *ptr;
44491 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44492 _v = 0;
44493 PyErr_Clear();
44494 } else {
44495 _v = 1;
44496 }
44497 }
44498 if (_v) {
44499 {
44500 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44501 }
44502 if (_v) {
44503 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44504 }
44505 }
44506 }
44507 }
44508 if (argc == 3) {
44509 int _v;
44510 {
44511 void *ptr;
44512 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44513 _v = 0;
44514 PyErr_Clear();
44515 } else {
44516 _v = 1;
44517 }
44518 }
44519 if (_v) {
44520 {
44521 void *ptr;
44522 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44523 _v = 0;
44524 PyErr_Clear();
44525 } else {
44526 _v = 1;
44527 }
44528 }
44529 if (_v) {
44530 {
44531 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44532 }
44533 if (_v) {
44534 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44535 }
44536 }
44537 }
44538 }
44539 if (argc == 3) {
44540 int _v;
44541 {
44542 void *ptr;
44543 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44544 _v = 0;
44545 PyErr_Clear();
44546 } else {
44547 _v = 1;
44548 }
44549 }
44550 if (_v) {
44551 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44552 if (_v) {
44553 {
44554 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44555 }
44556 if (_v) {
44557 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44558 }
44559 }
44560 }
44561 }
44562
44563 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44564 return NULL;
44565 }
44566
44567
44568 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44569 PyObject *resultobj = NULL;
44570 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44571 wxWindow *arg2 = (wxWindow *) 0 ;
44572 wxGBSpan result;
44573 PyObject * obj0 = 0 ;
44574 PyObject * obj1 = 0 ;
44575
44576 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44578 if (SWIG_arg_fail(1)) SWIG_fail;
44579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44580 if (SWIG_arg_fail(2)) SWIG_fail;
44581 {
44582 PyThreadState* __tstate = wxPyBeginAllowThreads();
44583 result = (arg1)->GetItemSpan(arg2);
44584
44585 wxPyEndAllowThreads(__tstate);
44586 if (PyErr_Occurred()) SWIG_fail;
44587 }
44588 {
44589 wxGBSpan * resultptr;
44590 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44592 }
44593 return resultobj;
44594 fail:
44595 return NULL;
44596 }
44597
44598
44599 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44600 PyObject *resultobj = NULL;
44601 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44602 wxSizer *arg2 = (wxSizer *) 0 ;
44603 wxGBSpan result;
44604 PyObject * obj0 = 0 ;
44605 PyObject * obj1 = 0 ;
44606
44607 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44609 if (SWIG_arg_fail(1)) SWIG_fail;
44610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44611 if (SWIG_arg_fail(2)) SWIG_fail;
44612 {
44613 PyThreadState* __tstate = wxPyBeginAllowThreads();
44614 result = (arg1)->GetItemSpan(arg2);
44615
44616 wxPyEndAllowThreads(__tstate);
44617 if (PyErr_Occurred()) SWIG_fail;
44618 }
44619 {
44620 wxGBSpan * resultptr;
44621 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44622 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44623 }
44624 return resultobj;
44625 fail:
44626 return NULL;
44627 }
44628
44629
44630 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44631 PyObject *resultobj = NULL;
44632 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44633 size_t arg2 ;
44634 wxGBSpan result;
44635 PyObject * obj0 = 0 ;
44636 PyObject * obj1 = 0 ;
44637
44638 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44640 if (SWIG_arg_fail(1)) SWIG_fail;
44641 {
44642 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44643 if (SWIG_arg_fail(2)) SWIG_fail;
44644 }
44645 {
44646 PyThreadState* __tstate = wxPyBeginAllowThreads();
44647 result = (arg1)->GetItemSpan(arg2);
44648
44649 wxPyEndAllowThreads(__tstate);
44650 if (PyErr_Occurred()) SWIG_fail;
44651 }
44652 {
44653 wxGBSpan * resultptr;
44654 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44655 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44656 }
44657 return resultobj;
44658 fail:
44659 return NULL;
44660 }
44661
44662
44663 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44664 int argc;
44665 PyObject *argv[3];
44666 int ii;
44667
44668 argc = PyObject_Length(args);
44669 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44670 argv[ii] = PyTuple_GetItem(args,ii);
44671 }
44672 if (argc == 2) {
44673 int _v;
44674 {
44675 void *ptr;
44676 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44677 _v = 0;
44678 PyErr_Clear();
44679 } else {
44680 _v = 1;
44681 }
44682 }
44683 if (_v) {
44684 {
44685 void *ptr;
44686 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44687 _v = 0;
44688 PyErr_Clear();
44689 } else {
44690 _v = 1;
44691 }
44692 }
44693 if (_v) {
44694 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44695 }
44696 }
44697 }
44698 if (argc == 2) {
44699 int _v;
44700 {
44701 void *ptr;
44702 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44703 _v = 0;
44704 PyErr_Clear();
44705 } else {
44706 _v = 1;
44707 }
44708 }
44709 if (_v) {
44710 {
44711 void *ptr;
44712 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44713 _v = 0;
44714 PyErr_Clear();
44715 } else {
44716 _v = 1;
44717 }
44718 }
44719 if (_v) {
44720 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44721 }
44722 }
44723 }
44724 if (argc == 2) {
44725 int _v;
44726 {
44727 void *ptr;
44728 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44729 _v = 0;
44730 PyErr_Clear();
44731 } else {
44732 _v = 1;
44733 }
44734 }
44735 if (_v) {
44736 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44737 if (_v) {
44738 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44739 }
44740 }
44741 }
44742
44743 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44744 return NULL;
44745 }
44746
44747
44748 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44749 PyObject *resultobj = NULL;
44750 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44751 wxWindow *arg2 = (wxWindow *) 0 ;
44752 wxGBSpan *arg3 = 0 ;
44753 bool result;
44754 wxGBSpan temp3 ;
44755 PyObject * obj0 = 0 ;
44756 PyObject * obj1 = 0 ;
44757 PyObject * obj2 = 0 ;
44758
44759 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44761 if (SWIG_arg_fail(1)) SWIG_fail;
44762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44763 if (SWIG_arg_fail(2)) SWIG_fail;
44764 {
44765 arg3 = &temp3;
44766 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44767 }
44768 {
44769 PyThreadState* __tstate = wxPyBeginAllowThreads();
44770 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44771
44772 wxPyEndAllowThreads(__tstate);
44773 if (PyErr_Occurred()) SWIG_fail;
44774 }
44775 {
44776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44777 }
44778 return resultobj;
44779 fail:
44780 return NULL;
44781 }
44782
44783
44784 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44785 PyObject *resultobj = NULL;
44786 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44787 wxSizer *arg2 = (wxSizer *) 0 ;
44788 wxGBSpan *arg3 = 0 ;
44789 bool result;
44790 wxGBSpan temp3 ;
44791 PyObject * obj0 = 0 ;
44792 PyObject * obj1 = 0 ;
44793 PyObject * obj2 = 0 ;
44794
44795 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44797 if (SWIG_arg_fail(1)) SWIG_fail;
44798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44799 if (SWIG_arg_fail(2)) SWIG_fail;
44800 {
44801 arg3 = &temp3;
44802 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44803 }
44804 {
44805 PyThreadState* __tstate = wxPyBeginAllowThreads();
44806 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44807
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 {
44812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44813 }
44814 return resultobj;
44815 fail:
44816 return NULL;
44817 }
44818
44819
44820 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44821 PyObject *resultobj = NULL;
44822 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44823 size_t arg2 ;
44824 wxGBSpan *arg3 = 0 ;
44825 bool result;
44826 wxGBSpan temp3 ;
44827 PyObject * obj0 = 0 ;
44828 PyObject * obj1 = 0 ;
44829 PyObject * obj2 = 0 ;
44830
44831 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44833 if (SWIG_arg_fail(1)) SWIG_fail;
44834 {
44835 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44836 if (SWIG_arg_fail(2)) SWIG_fail;
44837 }
44838 {
44839 arg3 = &temp3;
44840 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44841 }
44842 {
44843 PyThreadState* __tstate = wxPyBeginAllowThreads();
44844 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44845
44846 wxPyEndAllowThreads(__tstate);
44847 if (PyErr_Occurred()) SWIG_fail;
44848 }
44849 {
44850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44851 }
44852 return resultobj;
44853 fail:
44854 return NULL;
44855 }
44856
44857
44858 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44859 int argc;
44860 PyObject *argv[4];
44861 int ii;
44862
44863 argc = PyObject_Length(args);
44864 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44865 argv[ii] = PyTuple_GetItem(args,ii);
44866 }
44867 if (argc == 3) {
44868 int _v;
44869 {
44870 void *ptr;
44871 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44872 _v = 0;
44873 PyErr_Clear();
44874 } else {
44875 _v = 1;
44876 }
44877 }
44878 if (_v) {
44879 {
44880 void *ptr;
44881 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44882 _v = 0;
44883 PyErr_Clear();
44884 } else {
44885 _v = 1;
44886 }
44887 }
44888 if (_v) {
44889 {
44890 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44891 }
44892 if (_v) {
44893 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44894 }
44895 }
44896 }
44897 }
44898 if (argc == 3) {
44899 int _v;
44900 {
44901 void *ptr;
44902 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44903 _v = 0;
44904 PyErr_Clear();
44905 } else {
44906 _v = 1;
44907 }
44908 }
44909 if (_v) {
44910 {
44911 void *ptr;
44912 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44913 _v = 0;
44914 PyErr_Clear();
44915 } else {
44916 _v = 1;
44917 }
44918 }
44919 if (_v) {
44920 {
44921 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44922 }
44923 if (_v) {
44924 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44925 }
44926 }
44927 }
44928 }
44929 if (argc == 3) {
44930 int _v;
44931 {
44932 void *ptr;
44933 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44934 _v = 0;
44935 PyErr_Clear();
44936 } else {
44937 _v = 1;
44938 }
44939 }
44940 if (_v) {
44941 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44942 if (_v) {
44943 {
44944 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44945 }
44946 if (_v) {
44947 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44948 }
44949 }
44950 }
44951 }
44952
44953 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44954 return NULL;
44955 }
44956
44957
44958 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44959 PyObject *resultobj = NULL;
44960 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44961 wxWindow *arg2 = (wxWindow *) 0 ;
44962 wxGBSizerItem *result;
44963 PyObject * obj0 = 0 ;
44964 PyObject * obj1 = 0 ;
44965
44966 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44968 if (SWIG_arg_fail(1)) SWIG_fail;
44969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44970 if (SWIG_arg_fail(2)) SWIG_fail;
44971 {
44972 PyThreadState* __tstate = wxPyBeginAllowThreads();
44973 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44974
44975 wxPyEndAllowThreads(__tstate);
44976 if (PyErr_Occurred()) SWIG_fail;
44977 }
44978 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44979 return resultobj;
44980 fail:
44981 return NULL;
44982 }
44983
44984
44985 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44986 PyObject *resultobj = NULL;
44987 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44988 wxSizer *arg2 = (wxSizer *) 0 ;
44989 wxGBSizerItem *result;
44990 PyObject * obj0 = 0 ;
44991 PyObject * obj1 = 0 ;
44992
44993 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44995 if (SWIG_arg_fail(1)) SWIG_fail;
44996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44997 if (SWIG_arg_fail(2)) SWIG_fail;
44998 {
44999 PyThreadState* __tstate = wxPyBeginAllowThreads();
45000 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
45001
45002 wxPyEndAllowThreads(__tstate);
45003 if (PyErr_Occurred()) SWIG_fail;
45004 }
45005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45006 return resultobj;
45007 fail:
45008 return NULL;
45009 }
45010
45011
45012 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
45013 int argc;
45014 PyObject *argv[3];
45015 int ii;
45016
45017 argc = PyObject_Length(args);
45018 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
45019 argv[ii] = PyTuple_GetItem(args,ii);
45020 }
45021 if (argc == 2) {
45022 int _v;
45023 {
45024 void *ptr;
45025 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
45026 _v = 0;
45027 PyErr_Clear();
45028 } else {
45029 _v = 1;
45030 }
45031 }
45032 if (_v) {
45033 {
45034 void *ptr;
45035 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
45036 _v = 0;
45037 PyErr_Clear();
45038 } else {
45039 _v = 1;
45040 }
45041 }
45042 if (_v) {
45043 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
45044 }
45045 }
45046 }
45047 if (argc == 2) {
45048 int _v;
45049 {
45050 void *ptr;
45051 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
45052 _v = 0;
45053 PyErr_Clear();
45054 } else {
45055 _v = 1;
45056 }
45057 }
45058 if (_v) {
45059 {
45060 void *ptr;
45061 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
45062 _v = 0;
45063 PyErr_Clear();
45064 } else {
45065 _v = 1;
45066 }
45067 }
45068 if (_v) {
45069 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
45070 }
45071 }
45072 }
45073
45074 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
45075 return NULL;
45076 }
45077
45078
45079 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
45080 PyObject *resultobj = NULL;
45081 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45082 wxGBPosition *arg2 = 0 ;
45083 wxGBSizerItem *result;
45084 wxGBPosition temp2 ;
45085 PyObject * obj0 = 0 ;
45086 PyObject * obj1 = 0 ;
45087 char *kwnames[] = {
45088 (char *) "self",(char *) "pos", NULL
45089 };
45090
45091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
45092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45093 if (SWIG_arg_fail(1)) SWIG_fail;
45094 {
45095 arg2 = &temp2;
45096 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45097 }
45098 {
45099 PyThreadState* __tstate = wxPyBeginAllowThreads();
45100 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
45101
45102 wxPyEndAllowThreads(__tstate);
45103 if (PyErr_Occurred()) SWIG_fail;
45104 }
45105 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45106 return resultobj;
45107 fail:
45108 return NULL;
45109 }
45110
45111
45112 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
45113 PyObject *resultobj = NULL;
45114 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45115 wxPoint *arg2 = 0 ;
45116 wxGBSizerItem *result;
45117 wxPoint temp2 ;
45118 PyObject * obj0 = 0 ;
45119 PyObject * obj1 = 0 ;
45120 char *kwnames[] = {
45121 (char *) "self",(char *) "pt", NULL
45122 };
45123
45124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
45125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45126 if (SWIG_arg_fail(1)) SWIG_fail;
45127 {
45128 arg2 = &temp2;
45129 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45130 }
45131 {
45132 PyThreadState* __tstate = wxPyBeginAllowThreads();
45133 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
45134
45135 wxPyEndAllowThreads(__tstate);
45136 if (PyErr_Occurred()) SWIG_fail;
45137 }
45138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45139 return resultobj;
45140 fail:
45141 return NULL;
45142 }
45143
45144
45145 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
45146 PyObject *resultobj = NULL;
45147 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45148 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
45149 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
45150 bool result;
45151 PyObject * obj0 = 0 ;
45152 PyObject * obj1 = 0 ;
45153 PyObject * obj2 = 0 ;
45154 char *kwnames[] = {
45155 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
45156 };
45157
45158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
45159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45160 if (SWIG_arg_fail(1)) SWIG_fail;
45161 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45162 if (SWIG_arg_fail(2)) SWIG_fail;
45163 if (obj2) {
45164 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45165 if (SWIG_arg_fail(3)) SWIG_fail;
45166 }
45167 {
45168 PyThreadState* __tstate = wxPyBeginAllowThreads();
45169 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
45170
45171 wxPyEndAllowThreads(__tstate);
45172 if (PyErr_Occurred()) SWIG_fail;
45173 }
45174 {
45175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45176 }
45177 return resultobj;
45178 fail:
45179 return NULL;
45180 }
45181
45182
45183 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
45184 PyObject *resultobj = NULL;
45185 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45186 wxGBPosition *arg2 = 0 ;
45187 wxGBSpan *arg3 = 0 ;
45188 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45189 bool result;
45190 wxGBPosition temp2 ;
45191 wxGBSpan temp3 ;
45192 PyObject * obj0 = 0 ;
45193 PyObject * obj1 = 0 ;
45194 PyObject * obj2 = 0 ;
45195 PyObject * obj3 = 0 ;
45196 char *kwnames[] = {
45197 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45198 };
45199
45200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45202 if (SWIG_arg_fail(1)) SWIG_fail;
45203 {
45204 arg2 = &temp2;
45205 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45206 }
45207 {
45208 arg3 = &temp3;
45209 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45210 }
45211 if (obj3) {
45212 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45213 if (SWIG_arg_fail(4)) SWIG_fail;
45214 }
45215 {
45216 PyThreadState* __tstate = wxPyBeginAllowThreads();
45217 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45218
45219 wxPyEndAllowThreads(__tstate);
45220 if (PyErr_Occurred()) SWIG_fail;
45221 }
45222 {
45223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45224 }
45225 return resultobj;
45226 fail:
45227 return NULL;
45228 }
45229
45230
45231 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45232 PyObject *obj;
45233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45234 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45235 Py_INCREF(obj);
45236 return Py_BuildValue((char *)"");
45237 }
45238 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45239 PyObject *resultobj = NULL;
45240 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45241 wxRelationship arg2 ;
45242 wxWindow *arg3 = (wxWindow *) 0 ;
45243 wxEdge arg4 ;
45244 int arg5 = (int) 0 ;
45245 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45246 PyObject * obj0 = 0 ;
45247 PyObject * obj1 = 0 ;
45248 PyObject * obj2 = 0 ;
45249 PyObject * obj3 = 0 ;
45250 PyObject * obj4 = 0 ;
45251 PyObject * obj5 = 0 ;
45252 char *kwnames[] = {
45253 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45254 };
45255
45256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45258 if (SWIG_arg_fail(1)) SWIG_fail;
45259 {
45260 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45261 if (SWIG_arg_fail(2)) SWIG_fail;
45262 }
45263 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45264 if (SWIG_arg_fail(3)) SWIG_fail;
45265 {
45266 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45267 if (SWIG_arg_fail(4)) SWIG_fail;
45268 }
45269 if (obj4) {
45270 {
45271 arg5 = static_cast<int >(SWIG_As_int(obj4));
45272 if (SWIG_arg_fail(5)) SWIG_fail;
45273 }
45274 }
45275 if (obj5) {
45276 {
45277 arg6 = static_cast<int >(SWIG_As_int(obj5));
45278 if (SWIG_arg_fail(6)) SWIG_fail;
45279 }
45280 }
45281 {
45282 PyThreadState* __tstate = wxPyBeginAllowThreads();
45283 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45284
45285 wxPyEndAllowThreads(__tstate);
45286 if (PyErr_Occurred()) SWIG_fail;
45287 }
45288 Py_INCREF(Py_None); resultobj = Py_None;
45289 return resultobj;
45290 fail:
45291 return NULL;
45292 }
45293
45294
45295 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45296 PyObject *resultobj = NULL;
45297 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45298 wxWindow *arg2 = (wxWindow *) 0 ;
45299 int arg3 = (int) 0 ;
45300 PyObject * obj0 = 0 ;
45301 PyObject * obj1 = 0 ;
45302 PyObject * obj2 = 0 ;
45303 char *kwnames[] = {
45304 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45305 };
45306
45307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45309 if (SWIG_arg_fail(1)) SWIG_fail;
45310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45311 if (SWIG_arg_fail(2)) SWIG_fail;
45312 if (obj2) {
45313 {
45314 arg3 = static_cast<int >(SWIG_As_int(obj2));
45315 if (SWIG_arg_fail(3)) SWIG_fail;
45316 }
45317 }
45318 {
45319 PyThreadState* __tstate = wxPyBeginAllowThreads();
45320 (arg1)->LeftOf(arg2,arg3);
45321
45322 wxPyEndAllowThreads(__tstate);
45323 if (PyErr_Occurred()) SWIG_fail;
45324 }
45325 Py_INCREF(Py_None); resultobj = Py_None;
45326 return resultobj;
45327 fail:
45328 return NULL;
45329 }
45330
45331
45332 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45333 PyObject *resultobj = NULL;
45334 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45335 wxWindow *arg2 = (wxWindow *) 0 ;
45336 int arg3 = (int) 0 ;
45337 PyObject * obj0 = 0 ;
45338 PyObject * obj1 = 0 ;
45339 PyObject * obj2 = 0 ;
45340 char *kwnames[] = {
45341 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45342 };
45343
45344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45346 if (SWIG_arg_fail(1)) SWIG_fail;
45347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45348 if (SWIG_arg_fail(2)) SWIG_fail;
45349 if (obj2) {
45350 {
45351 arg3 = static_cast<int >(SWIG_As_int(obj2));
45352 if (SWIG_arg_fail(3)) SWIG_fail;
45353 }
45354 }
45355 {
45356 PyThreadState* __tstate = wxPyBeginAllowThreads();
45357 (arg1)->RightOf(arg2,arg3);
45358
45359 wxPyEndAllowThreads(__tstate);
45360 if (PyErr_Occurred()) SWIG_fail;
45361 }
45362 Py_INCREF(Py_None); resultobj = Py_None;
45363 return resultobj;
45364 fail:
45365 return NULL;
45366 }
45367
45368
45369 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45370 PyObject *resultobj = NULL;
45371 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45372 wxWindow *arg2 = (wxWindow *) 0 ;
45373 int arg3 = (int) 0 ;
45374 PyObject * obj0 = 0 ;
45375 PyObject * obj1 = 0 ;
45376 PyObject * obj2 = 0 ;
45377 char *kwnames[] = {
45378 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45379 };
45380
45381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45383 if (SWIG_arg_fail(1)) SWIG_fail;
45384 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45385 if (SWIG_arg_fail(2)) SWIG_fail;
45386 if (obj2) {
45387 {
45388 arg3 = static_cast<int >(SWIG_As_int(obj2));
45389 if (SWIG_arg_fail(3)) SWIG_fail;
45390 }
45391 }
45392 {
45393 PyThreadState* __tstate = wxPyBeginAllowThreads();
45394 (arg1)->Above(arg2,arg3);
45395
45396 wxPyEndAllowThreads(__tstate);
45397 if (PyErr_Occurred()) SWIG_fail;
45398 }
45399 Py_INCREF(Py_None); resultobj = Py_None;
45400 return resultobj;
45401 fail:
45402 return NULL;
45403 }
45404
45405
45406 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45407 PyObject *resultobj = NULL;
45408 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45409 wxWindow *arg2 = (wxWindow *) 0 ;
45410 int arg3 = (int) 0 ;
45411 PyObject * obj0 = 0 ;
45412 PyObject * obj1 = 0 ;
45413 PyObject * obj2 = 0 ;
45414 char *kwnames[] = {
45415 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45416 };
45417
45418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45420 if (SWIG_arg_fail(1)) SWIG_fail;
45421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45422 if (SWIG_arg_fail(2)) SWIG_fail;
45423 if (obj2) {
45424 {
45425 arg3 = static_cast<int >(SWIG_As_int(obj2));
45426 if (SWIG_arg_fail(3)) SWIG_fail;
45427 }
45428 }
45429 {
45430 PyThreadState* __tstate = wxPyBeginAllowThreads();
45431 (arg1)->Below(arg2,arg3);
45432
45433 wxPyEndAllowThreads(__tstate);
45434 if (PyErr_Occurred()) SWIG_fail;
45435 }
45436 Py_INCREF(Py_None); resultobj = Py_None;
45437 return resultobj;
45438 fail:
45439 return NULL;
45440 }
45441
45442
45443 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45444 PyObject *resultobj = NULL;
45445 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45446 wxWindow *arg2 = (wxWindow *) 0 ;
45447 wxEdge arg3 ;
45448 int arg4 = (int) 0 ;
45449 PyObject * obj0 = 0 ;
45450 PyObject * obj1 = 0 ;
45451 PyObject * obj2 = 0 ;
45452 PyObject * obj3 = 0 ;
45453 char *kwnames[] = {
45454 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45455 };
45456
45457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45459 if (SWIG_arg_fail(1)) SWIG_fail;
45460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45461 if (SWIG_arg_fail(2)) SWIG_fail;
45462 {
45463 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45464 if (SWIG_arg_fail(3)) SWIG_fail;
45465 }
45466 if (obj3) {
45467 {
45468 arg4 = static_cast<int >(SWIG_As_int(obj3));
45469 if (SWIG_arg_fail(4)) SWIG_fail;
45470 }
45471 }
45472 {
45473 PyThreadState* __tstate = wxPyBeginAllowThreads();
45474 (arg1)->SameAs(arg2,arg3,arg4);
45475
45476 wxPyEndAllowThreads(__tstate);
45477 if (PyErr_Occurred()) SWIG_fail;
45478 }
45479 Py_INCREF(Py_None); resultobj = Py_None;
45480 return resultobj;
45481 fail:
45482 return NULL;
45483 }
45484
45485
45486 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45487 PyObject *resultobj = NULL;
45488 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45489 wxWindow *arg2 = (wxWindow *) 0 ;
45490 wxEdge arg3 ;
45491 int arg4 ;
45492 PyObject * obj0 = 0 ;
45493 PyObject * obj1 = 0 ;
45494 PyObject * obj2 = 0 ;
45495 PyObject * obj3 = 0 ;
45496 char *kwnames[] = {
45497 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45498 };
45499
45500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45502 if (SWIG_arg_fail(1)) SWIG_fail;
45503 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45504 if (SWIG_arg_fail(2)) SWIG_fail;
45505 {
45506 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45507 if (SWIG_arg_fail(3)) SWIG_fail;
45508 }
45509 {
45510 arg4 = static_cast<int >(SWIG_As_int(obj3));
45511 if (SWIG_arg_fail(4)) SWIG_fail;
45512 }
45513 {
45514 PyThreadState* __tstate = wxPyBeginAllowThreads();
45515 (arg1)->PercentOf(arg2,arg3,arg4);
45516
45517 wxPyEndAllowThreads(__tstate);
45518 if (PyErr_Occurred()) SWIG_fail;
45519 }
45520 Py_INCREF(Py_None); resultobj = Py_None;
45521 return resultobj;
45522 fail:
45523 return NULL;
45524 }
45525
45526
45527 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45528 PyObject *resultobj = NULL;
45529 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45530 int arg2 ;
45531 PyObject * obj0 = 0 ;
45532 PyObject * obj1 = 0 ;
45533 char *kwnames[] = {
45534 (char *) "self",(char *) "val", NULL
45535 };
45536
45537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45539 if (SWIG_arg_fail(1)) SWIG_fail;
45540 {
45541 arg2 = static_cast<int >(SWIG_As_int(obj1));
45542 if (SWIG_arg_fail(2)) SWIG_fail;
45543 }
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 (arg1)->Absolute(arg2);
45547
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 Py_INCREF(Py_None); resultobj = Py_None;
45552 return resultobj;
45553 fail:
45554 return NULL;
45555 }
45556
45557
45558 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45559 PyObject *resultobj = NULL;
45560 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45561 PyObject * obj0 = 0 ;
45562 char *kwnames[] = {
45563 (char *) "self", NULL
45564 };
45565
45566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45568 if (SWIG_arg_fail(1)) SWIG_fail;
45569 {
45570 PyThreadState* __tstate = wxPyBeginAllowThreads();
45571 (arg1)->Unconstrained();
45572
45573 wxPyEndAllowThreads(__tstate);
45574 if (PyErr_Occurred()) SWIG_fail;
45575 }
45576 Py_INCREF(Py_None); resultobj = Py_None;
45577 return resultobj;
45578 fail:
45579 return NULL;
45580 }
45581
45582
45583 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45584 PyObject *resultobj = NULL;
45585 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45586 PyObject * obj0 = 0 ;
45587 char *kwnames[] = {
45588 (char *) "self", NULL
45589 };
45590
45591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45593 if (SWIG_arg_fail(1)) SWIG_fail;
45594 {
45595 PyThreadState* __tstate = wxPyBeginAllowThreads();
45596 (arg1)->AsIs();
45597
45598 wxPyEndAllowThreads(__tstate);
45599 if (PyErr_Occurred()) SWIG_fail;
45600 }
45601 Py_INCREF(Py_None); resultobj = Py_None;
45602 return resultobj;
45603 fail:
45604 return NULL;
45605 }
45606
45607
45608 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45609 PyObject *resultobj = NULL;
45610 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45611 wxWindow *result;
45612 PyObject * obj0 = 0 ;
45613 char *kwnames[] = {
45614 (char *) "self", NULL
45615 };
45616
45617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45619 if (SWIG_arg_fail(1)) SWIG_fail;
45620 {
45621 PyThreadState* __tstate = wxPyBeginAllowThreads();
45622 result = (wxWindow *)(arg1)->GetOtherWindow();
45623
45624 wxPyEndAllowThreads(__tstate);
45625 if (PyErr_Occurred()) SWIG_fail;
45626 }
45627 {
45628 resultobj = wxPyMake_wxObject(result, 0);
45629 }
45630 return resultobj;
45631 fail:
45632 return NULL;
45633 }
45634
45635
45636 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45637 PyObject *resultobj = NULL;
45638 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45639 wxEdge result;
45640 PyObject * obj0 = 0 ;
45641 char *kwnames[] = {
45642 (char *) "self", NULL
45643 };
45644
45645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45647 if (SWIG_arg_fail(1)) SWIG_fail;
45648 {
45649 PyThreadState* __tstate = wxPyBeginAllowThreads();
45650 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45651
45652 wxPyEndAllowThreads(__tstate);
45653 if (PyErr_Occurred()) SWIG_fail;
45654 }
45655 resultobj = SWIG_From_int((result));
45656 return resultobj;
45657 fail:
45658 return NULL;
45659 }
45660
45661
45662 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45663 PyObject *resultobj = NULL;
45664 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45665 wxEdge arg2 ;
45666 PyObject * obj0 = 0 ;
45667 PyObject * obj1 = 0 ;
45668 char *kwnames[] = {
45669 (char *) "self",(char *) "which", NULL
45670 };
45671
45672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45674 if (SWIG_arg_fail(1)) SWIG_fail;
45675 {
45676 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45677 if (SWIG_arg_fail(2)) SWIG_fail;
45678 }
45679 {
45680 PyThreadState* __tstate = wxPyBeginAllowThreads();
45681 (arg1)->SetEdge(arg2);
45682
45683 wxPyEndAllowThreads(__tstate);
45684 if (PyErr_Occurred()) SWIG_fail;
45685 }
45686 Py_INCREF(Py_None); resultobj = Py_None;
45687 return resultobj;
45688 fail:
45689 return NULL;
45690 }
45691
45692
45693 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45694 PyObject *resultobj = NULL;
45695 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45696 int arg2 ;
45697 PyObject * obj0 = 0 ;
45698 PyObject * obj1 = 0 ;
45699 char *kwnames[] = {
45700 (char *) "self",(char *) "v", NULL
45701 };
45702
45703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45705 if (SWIG_arg_fail(1)) SWIG_fail;
45706 {
45707 arg2 = static_cast<int >(SWIG_As_int(obj1));
45708 if (SWIG_arg_fail(2)) SWIG_fail;
45709 }
45710 {
45711 PyThreadState* __tstate = wxPyBeginAllowThreads();
45712 (arg1)->SetValue(arg2);
45713
45714 wxPyEndAllowThreads(__tstate);
45715 if (PyErr_Occurred()) SWIG_fail;
45716 }
45717 Py_INCREF(Py_None); resultobj = Py_None;
45718 return resultobj;
45719 fail:
45720 return NULL;
45721 }
45722
45723
45724 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45725 PyObject *resultobj = NULL;
45726 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45727 int result;
45728 PyObject * obj0 = 0 ;
45729 char *kwnames[] = {
45730 (char *) "self", NULL
45731 };
45732
45733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
45738 result = (int)(arg1)->GetMargin();
45739
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 {
45744 resultobj = SWIG_From_int(static_cast<int >(result));
45745 }
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = NULL;
45754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45755 int arg2 ;
45756 PyObject * obj0 = 0 ;
45757 PyObject * obj1 = 0 ;
45758 char *kwnames[] = {
45759 (char *) "self",(char *) "m", NULL
45760 };
45761
45762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45764 if (SWIG_arg_fail(1)) SWIG_fail;
45765 {
45766 arg2 = static_cast<int >(SWIG_As_int(obj1));
45767 if (SWIG_arg_fail(2)) SWIG_fail;
45768 }
45769 {
45770 PyThreadState* __tstate = wxPyBeginAllowThreads();
45771 (arg1)->SetMargin(arg2);
45772
45773 wxPyEndAllowThreads(__tstate);
45774 if (PyErr_Occurred()) SWIG_fail;
45775 }
45776 Py_INCREF(Py_None); resultobj = Py_None;
45777 return resultobj;
45778 fail:
45779 return NULL;
45780 }
45781
45782
45783 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45784 PyObject *resultobj = NULL;
45785 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45786 int result;
45787 PyObject * obj0 = 0 ;
45788 char *kwnames[] = {
45789 (char *) "self", NULL
45790 };
45791
45792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45794 if (SWIG_arg_fail(1)) SWIG_fail;
45795 {
45796 PyThreadState* __tstate = wxPyBeginAllowThreads();
45797 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45798
45799 wxPyEndAllowThreads(__tstate);
45800 if (PyErr_Occurred()) SWIG_fail;
45801 }
45802 {
45803 resultobj = SWIG_From_int(static_cast<int >(result));
45804 }
45805 return resultobj;
45806 fail:
45807 return NULL;
45808 }
45809
45810
45811 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45812 PyObject *resultobj = NULL;
45813 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45814 int result;
45815 PyObject * obj0 = 0 ;
45816 char *kwnames[] = {
45817 (char *) "self", NULL
45818 };
45819
45820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45822 if (SWIG_arg_fail(1)) SWIG_fail;
45823 {
45824 PyThreadState* __tstate = wxPyBeginAllowThreads();
45825 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45826
45827 wxPyEndAllowThreads(__tstate);
45828 if (PyErr_Occurred()) SWIG_fail;
45829 }
45830 {
45831 resultobj = SWIG_From_int(static_cast<int >(result));
45832 }
45833 return resultobj;
45834 fail:
45835 return NULL;
45836 }
45837
45838
45839 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45840 PyObject *resultobj = NULL;
45841 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45842 int result;
45843 PyObject * obj0 = 0 ;
45844 char *kwnames[] = {
45845 (char *) "self", NULL
45846 };
45847
45848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45850 if (SWIG_arg_fail(1)) SWIG_fail;
45851 {
45852 PyThreadState* __tstate = wxPyBeginAllowThreads();
45853 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45854
45855 wxPyEndAllowThreads(__tstate);
45856 if (PyErr_Occurred()) SWIG_fail;
45857 }
45858 {
45859 resultobj = SWIG_From_int(static_cast<int >(result));
45860 }
45861 return resultobj;
45862 fail:
45863 return NULL;
45864 }
45865
45866
45867 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45868 PyObject *resultobj = NULL;
45869 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45870 bool result;
45871 PyObject * obj0 = 0 ;
45872 char *kwnames[] = {
45873 (char *) "self", NULL
45874 };
45875
45876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45878 if (SWIG_arg_fail(1)) SWIG_fail;
45879 {
45880 PyThreadState* __tstate = wxPyBeginAllowThreads();
45881 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45882
45883 wxPyEndAllowThreads(__tstate);
45884 if (PyErr_Occurred()) SWIG_fail;
45885 }
45886 {
45887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45888 }
45889 return resultobj;
45890 fail:
45891 return NULL;
45892 }
45893
45894
45895 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45896 PyObject *resultobj = NULL;
45897 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45898 bool arg2 ;
45899 PyObject * obj0 = 0 ;
45900 PyObject * obj1 = 0 ;
45901 char *kwnames[] = {
45902 (char *) "self",(char *) "d", NULL
45903 };
45904
45905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45907 if (SWIG_arg_fail(1)) SWIG_fail;
45908 {
45909 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45910 if (SWIG_arg_fail(2)) SWIG_fail;
45911 }
45912 {
45913 PyThreadState* __tstate = wxPyBeginAllowThreads();
45914 (arg1)->SetDone(arg2);
45915
45916 wxPyEndAllowThreads(__tstate);
45917 if (PyErr_Occurred()) SWIG_fail;
45918 }
45919 Py_INCREF(Py_None); resultobj = Py_None;
45920 return resultobj;
45921 fail:
45922 return NULL;
45923 }
45924
45925
45926 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45927 PyObject *resultobj = NULL;
45928 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45929 wxRelationship result;
45930 PyObject * obj0 = 0 ;
45931 char *kwnames[] = {
45932 (char *) "self", NULL
45933 };
45934
45935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45937 if (SWIG_arg_fail(1)) SWIG_fail;
45938 {
45939 PyThreadState* __tstate = wxPyBeginAllowThreads();
45940 result = (wxRelationship)(arg1)->GetRelationship();
45941
45942 wxPyEndAllowThreads(__tstate);
45943 if (PyErr_Occurred()) SWIG_fail;
45944 }
45945 resultobj = SWIG_From_int((result));
45946 return resultobj;
45947 fail:
45948 return NULL;
45949 }
45950
45951
45952 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45953 PyObject *resultobj = NULL;
45954 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45955 wxRelationship arg2 ;
45956 PyObject * obj0 = 0 ;
45957 PyObject * obj1 = 0 ;
45958 char *kwnames[] = {
45959 (char *) "self",(char *) "r", NULL
45960 };
45961
45962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45964 if (SWIG_arg_fail(1)) SWIG_fail;
45965 {
45966 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45967 if (SWIG_arg_fail(2)) SWIG_fail;
45968 }
45969 {
45970 PyThreadState* __tstate = wxPyBeginAllowThreads();
45971 (arg1)->SetRelationship(arg2);
45972
45973 wxPyEndAllowThreads(__tstate);
45974 if (PyErr_Occurred()) SWIG_fail;
45975 }
45976 Py_INCREF(Py_None); resultobj = Py_None;
45977 return resultobj;
45978 fail:
45979 return NULL;
45980 }
45981
45982
45983 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45984 PyObject *resultobj = NULL;
45985 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45986 wxWindow *arg2 = (wxWindow *) 0 ;
45987 bool result;
45988 PyObject * obj0 = 0 ;
45989 PyObject * obj1 = 0 ;
45990 char *kwnames[] = {
45991 (char *) "self",(char *) "otherW", NULL
45992 };
45993
45994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45996 if (SWIG_arg_fail(1)) SWIG_fail;
45997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45998 if (SWIG_arg_fail(2)) SWIG_fail;
45999 {
46000 PyThreadState* __tstate = wxPyBeginAllowThreads();
46001 result = (bool)(arg1)->ResetIfWin(arg2);
46002
46003 wxPyEndAllowThreads(__tstate);
46004 if (PyErr_Occurred()) SWIG_fail;
46005 }
46006 {
46007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46008 }
46009 return resultobj;
46010 fail:
46011 return NULL;
46012 }
46013
46014
46015 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
46016 PyObject *resultobj = NULL;
46017 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46018 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
46019 wxWindow *arg3 = (wxWindow *) 0 ;
46020 bool result;
46021 PyObject * obj0 = 0 ;
46022 PyObject * obj1 = 0 ;
46023 PyObject * obj2 = 0 ;
46024 char *kwnames[] = {
46025 (char *) "self",(char *) "constraints",(char *) "win", NULL
46026 };
46027
46028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
46029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46030 if (SWIG_arg_fail(1)) SWIG_fail;
46031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46032 if (SWIG_arg_fail(2)) SWIG_fail;
46033 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46034 if (SWIG_arg_fail(3)) SWIG_fail;
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
46038
46039 wxPyEndAllowThreads(__tstate);
46040 if (PyErr_Occurred()) SWIG_fail;
46041 }
46042 {
46043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46044 }
46045 return resultobj;
46046 fail:
46047 return NULL;
46048 }
46049
46050
46051 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
46052 PyObject *resultobj = NULL;
46053 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46054 wxEdge arg2 ;
46055 wxWindow *arg3 = (wxWindow *) 0 ;
46056 wxWindow *arg4 = (wxWindow *) 0 ;
46057 int result;
46058 PyObject * obj0 = 0 ;
46059 PyObject * obj1 = 0 ;
46060 PyObject * obj2 = 0 ;
46061 PyObject * obj3 = 0 ;
46062 char *kwnames[] = {
46063 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
46064 };
46065
46066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
46067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46068 if (SWIG_arg_fail(1)) SWIG_fail;
46069 {
46070 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
46071 if (SWIG_arg_fail(2)) SWIG_fail;
46072 }
46073 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46074 if (SWIG_arg_fail(3)) SWIG_fail;
46075 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46076 if (SWIG_arg_fail(4)) SWIG_fail;
46077 {
46078 PyThreadState* __tstate = wxPyBeginAllowThreads();
46079 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
46080
46081 wxPyEndAllowThreads(__tstate);
46082 if (PyErr_Occurred()) SWIG_fail;
46083 }
46084 {
46085 resultobj = SWIG_From_int(static_cast<int >(result));
46086 }
46087 return resultobj;
46088 fail:
46089 return NULL;
46090 }
46091
46092
46093 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
46094 PyObject *obj;
46095 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46096 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
46097 Py_INCREF(obj);
46098 return Py_BuildValue((char *)"");
46099 }
46100 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
46101 PyObject *resultobj = NULL;
46102 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46103 wxIndividualLayoutConstraint *result;
46104 PyObject * obj0 = 0 ;
46105 char *kwnames[] = {
46106 (char *) "self", NULL
46107 };
46108
46109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
46110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46111 if (SWIG_arg_fail(1)) SWIG_fail;
46112 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
46113
46114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46115 return resultobj;
46116 fail:
46117 return NULL;
46118 }
46119
46120
46121 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
46122 PyObject *resultobj = NULL;
46123 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46124 wxIndividualLayoutConstraint *result;
46125 PyObject * obj0 = 0 ;
46126 char *kwnames[] = {
46127 (char *) "self", NULL
46128 };
46129
46130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
46131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46132 if (SWIG_arg_fail(1)) SWIG_fail;
46133 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
46134
46135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46136 return resultobj;
46137 fail:
46138 return NULL;
46139 }
46140
46141
46142 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
46143 PyObject *resultobj = NULL;
46144 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46145 wxIndividualLayoutConstraint *result;
46146 PyObject * obj0 = 0 ;
46147 char *kwnames[] = {
46148 (char *) "self", NULL
46149 };
46150
46151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
46152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46153 if (SWIG_arg_fail(1)) SWIG_fail;
46154 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
46155
46156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46157 return resultobj;
46158 fail:
46159 return NULL;
46160 }
46161
46162
46163 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
46164 PyObject *resultobj = NULL;
46165 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46166 wxIndividualLayoutConstraint *result;
46167 PyObject * obj0 = 0 ;
46168 char *kwnames[] = {
46169 (char *) "self", NULL
46170 };
46171
46172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
46173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46174 if (SWIG_arg_fail(1)) SWIG_fail;
46175 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
46176
46177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46178 return resultobj;
46179 fail:
46180 return NULL;
46181 }
46182
46183
46184 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
46185 PyObject *resultobj = NULL;
46186 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46187 wxIndividualLayoutConstraint *result;
46188 PyObject * obj0 = 0 ;
46189 char *kwnames[] = {
46190 (char *) "self", NULL
46191 };
46192
46193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46195 if (SWIG_arg_fail(1)) SWIG_fail;
46196 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46197
46198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46199 return resultobj;
46200 fail:
46201 return NULL;
46202 }
46203
46204
46205 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46206 PyObject *resultobj = NULL;
46207 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46208 wxIndividualLayoutConstraint *result;
46209 PyObject * obj0 = 0 ;
46210 char *kwnames[] = {
46211 (char *) "self", NULL
46212 };
46213
46214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46216 if (SWIG_arg_fail(1)) SWIG_fail;
46217 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46218
46219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46220 return resultobj;
46221 fail:
46222 return NULL;
46223 }
46224
46225
46226 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
46227 PyObject *resultobj = NULL;
46228 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46229 wxIndividualLayoutConstraint *result;
46230 PyObject * obj0 = 0 ;
46231 char *kwnames[] = {
46232 (char *) "self", NULL
46233 };
46234
46235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
46236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46237 if (SWIG_arg_fail(1)) SWIG_fail;
46238 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
46239
46240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46241 return resultobj;
46242 fail:
46243 return NULL;
46244 }
46245
46246
46247 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
46248 PyObject *resultobj = NULL;
46249 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46250 wxIndividualLayoutConstraint *result;
46251 PyObject * obj0 = 0 ;
46252 char *kwnames[] = {
46253 (char *) "self", NULL
46254 };
46255
46256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
46257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46258 if (SWIG_arg_fail(1)) SWIG_fail;
46259 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
46260
46261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46262 return resultobj;
46263 fail:
46264 return NULL;
46265 }
46266
46267
46268 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46269 PyObject *resultobj = NULL;
46270 wxLayoutConstraints *result;
46271 char *kwnames[] = {
46272 NULL
46273 };
46274
46275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46276 {
46277 PyThreadState* __tstate = wxPyBeginAllowThreads();
46278 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46279
46280 wxPyEndAllowThreads(__tstate);
46281 if (PyErr_Occurred()) SWIG_fail;
46282 }
46283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46284 return resultobj;
46285 fail:
46286 return NULL;
46287 }
46288
46289
46290 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46291 PyObject *resultobj = NULL;
46292 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46293 wxWindow *arg2 = (wxWindow *) 0 ;
46294 int *arg3 = (int *) 0 ;
46295 bool result;
46296 int temp3 ;
46297 int res3 = 0 ;
46298 PyObject * obj0 = 0 ;
46299 PyObject * obj1 = 0 ;
46300 char *kwnames[] = {
46301 (char *) "self",(char *) "win", NULL
46302 };
46303
46304 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46307 if (SWIG_arg_fail(1)) SWIG_fail;
46308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46309 if (SWIG_arg_fail(2)) SWIG_fail;
46310 {
46311 PyThreadState* __tstate = wxPyBeginAllowThreads();
46312 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46313
46314 wxPyEndAllowThreads(__tstate);
46315 if (PyErr_Occurred()) SWIG_fail;
46316 }
46317 {
46318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46319 }
46320 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46321 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46322 return resultobj;
46323 fail:
46324 return NULL;
46325 }
46326
46327
46328 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46329 PyObject *resultobj = NULL;
46330 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46331 bool result;
46332 PyObject * obj0 = 0 ;
46333 char *kwnames[] = {
46334 (char *) "self", NULL
46335 };
46336
46337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46339 if (SWIG_arg_fail(1)) SWIG_fail;
46340 {
46341 PyThreadState* __tstate = wxPyBeginAllowThreads();
46342 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46343
46344 wxPyEndAllowThreads(__tstate);
46345 if (PyErr_Occurred()) SWIG_fail;
46346 }
46347 {
46348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46349 }
46350 return resultobj;
46351 fail:
46352 return NULL;
46353 }
46354
46355
46356 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46357 PyObject *obj;
46358 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46359 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46360 Py_INCREF(obj);
46361 return Py_BuildValue((char *)"");
46362 }
46363 static PyMethodDef SwigMethods[] = {
46364 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46365 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46366 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46369 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46390 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46403 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46418 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46473 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46501 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46520 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46522 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46530 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46531 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46543 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46555 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46559 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46565 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46575 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46585 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46588 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46595 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46603 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46611 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46695 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46697 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46699 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46701 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46703 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46705 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46707 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46709 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46711 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46713 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46715 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46717 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46719 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46733 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46751 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46754 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46757 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46769 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46774 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46780 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46786 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46849 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46856 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"KeyEvent_GetModifiers", (PyCFunction) _wrap_KeyEvent_GetModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46893 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46903 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46909 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46911 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46913 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46916 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46920 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46923 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46926 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46928 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46933 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46941 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46945 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46948 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46950 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46954 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46971 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46973 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46976 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46978 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46982 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46986 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46997 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
47000 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
47003 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
47007 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
47014 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
47019 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
47024 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
47028 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
47073 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
47093 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
47096 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
47103 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
47107 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
47117 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47285 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47287 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47314 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47329 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47344 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47347 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47351 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47367 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47369 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47372 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47381 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47383 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47384 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47386 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47388 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47390 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47391 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47392 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47393 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47401 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47402 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47403 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47405 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47407 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47408 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47409 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47410 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47411 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47412 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47413 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47415 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47419 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47421 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47422 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47425 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47427 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47431 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47432 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47434 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47435 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47437 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47438 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47439 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47440 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47441 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47445 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47446 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47447 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47456 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47459 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47460 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47461 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47463 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47465 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47466 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47467 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47468 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47469 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47470 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47471 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47472 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47475 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47477 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47478 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47480 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47483 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47487 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47488 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47489 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47490 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47491 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47492 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47494 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47496 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47499 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47502 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47503 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47504 { (char *)"delete_SizerItem", (PyCFunction) _wrap_delete_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47509 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47511 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47512 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47514 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47515 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47516 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47517 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47518 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47519 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47520 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47521 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47522 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47523 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47524 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47525 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47526 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47527 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47528 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47529 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47530 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47531 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47532 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47533 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47534 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47535 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47536 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47537 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47538 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47539 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47540 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47541 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47542 { (char *)"delete_Sizer", (PyCFunction) _wrap_delete_Sizer, METH_VARARGS | METH_KEYWORDS, NULL},
47543 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47544 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47545 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47546 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47547 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47548 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47549 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47550 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47551 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47552 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47553 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47554 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47555 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47556 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47557 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47558 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47559 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47560 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47561 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47562 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47563 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47564 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47565 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47566 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47567 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47568 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47569 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47570 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47571 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47572 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47573 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47574 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47575 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47576 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47577 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47578 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47579 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47580 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47581 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47582 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47583 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47584 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47585 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47586 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47587 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47588 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47589 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47590 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47591 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47592 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47593 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47594 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47595 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47596 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47597 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47598 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47599 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47600 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47601 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47602 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47603 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47604 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47605 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47606 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47607 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47608 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47609 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47610 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47611 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47612 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47613 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47614 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47615 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47616 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47617 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47618 { (char *)"delete_GBPosition", (PyCFunction) _wrap_delete_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47619 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47620 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47621 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47622 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47623 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47624 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47625 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47626 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47627 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47628 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47629 { (char *)"delete_GBSpan", (PyCFunction) _wrap_delete_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47630 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47631 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47632 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47633 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47634 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47635 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47636 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47637 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47638 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47639 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47640 { (char *)"delete_GBSizerItem", (PyCFunction) _wrap_delete_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47641 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47642 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47643 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47644 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47645 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47646 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47647 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47648 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47649 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47650 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47651 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47652 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47653 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47654 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47655 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47656 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47657 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47658 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47659 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47660 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47661 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47662 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47663 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47664 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47665 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47666 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47667 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47668 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47669 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47670 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47671 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47672 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47673 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47674 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47675 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47676 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47677 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47678 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47679 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47680 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47681 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47682 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47683 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47684 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47685 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47686 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47687 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47688 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47689 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47690 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47691 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47692 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47693 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47694 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47695 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47696 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47697 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47698 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47699 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47700 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47701 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47702 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47703 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47704 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47705 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47706 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47707 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47708 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47709 { NULL, NULL, 0, NULL }
47710 };
47711
47712
47713 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47714
47715 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47716 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47717 }
47718 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47719 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47720 }
47721 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47722 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47723 }
47724 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47725 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47726 }
47727 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47728 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47729 }
47730 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47731 return (void *)((wxSizer *) ((wxGridSizer *) x));
47732 }
47733 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47734 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47735 }
47736 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47737 return (void *)((wxSizer *) ((wxPySizer *) x));
47738 }
47739 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47740 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47741 }
47742 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47743 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47744 }
47745 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47746 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47747 }
47748 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47749 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47750 }
47751 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47752 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47753 }
47754 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47755 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47756 }
47757 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47758 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47759 }
47760 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47761 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47762 }
47763 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47764 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47765 }
47766 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47767 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47768 }
47769 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47770 return (void *)((wxEvent *) ((wxPyEvent *) x));
47771 }
47772 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47773 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47774 }
47775 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47776 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47777 }
47778 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47779 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47780 }
47781 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47782 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47783 }
47784 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47785 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47786 }
47787 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47788 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47789 }
47790 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47791 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47792 }
47793 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47794 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47795 }
47796 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47797 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47798 }
47799 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47800 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47801 }
47802 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47803 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47804 }
47805 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47806 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47807 }
47808 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47809 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47810 }
47811 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47812 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47813 }
47814 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47815 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47816 }
47817 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47818 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47819 }
47820 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47821 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47822 }
47823 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47824 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47825 }
47826 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47827 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47828 }
47829 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47830 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47831 }
47832 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47833 return (void *)((wxEvent *) ((wxShowEvent *) x));
47834 }
47835 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47836 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47837 }
47838 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47839 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47840 }
47841 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47842 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47843 }
47844 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47845 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47846 }
47847 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47848 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47849 }
47850 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47851 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47852 }
47853 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47854 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47855 }
47856 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47857 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47858 }
47859 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47860 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47861 }
47862 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47863 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47864 }
47865 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47866 return (void *)((wxControl *) ((wxControlWithItems *) x));
47867 }
47868 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47869 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47870 }
47871 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47872 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47873 }
47874 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47875 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47876 }
47877 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47878 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47879 }
47880 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47881 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47882 }
47883 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47884 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47885 }
47886 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47887 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47888 }
47889 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47890 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47891 }
47892 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47893 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47894 }
47895 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47896 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47897 }
47898 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47899 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47900 }
47901 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47902 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47903 }
47904 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47905 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47906 }
47907 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47908 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47909 }
47910 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47911 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47912 }
47913 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47914 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47915 }
47916 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47917 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47918 }
47919 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47920 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47921 }
47922 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47923 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47924 }
47925 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47926 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47927 }
47928 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47929 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47930 }
47931 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47932 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47933 }
47934 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47935 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47936 }
47937 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47938 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47939 }
47940 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47941 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47942 }
47943 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47944 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47945 }
47946 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47947 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47948 }
47949 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47950 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47951 }
47952 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47953 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47954 }
47955 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47956 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47957 }
47958 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47959 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47960 }
47961 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47962 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47963 }
47964 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47965 return (void *)((wxObject *) ((wxSizerItem *) x));
47966 }
47967 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47968 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47969 }
47970 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47971 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47972 }
47973 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47974 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47975 }
47976 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47977 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47978 }
47979 static void *_p_wxSizerTo_p_wxObject(void *x) {
47980 return (void *)((wxObject *) ((wxSizer *) x));
47981 }
47982 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47983 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47984 }
47985 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47986 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47987 }
47988 static void *_p_wxEventTo_p_wxObject(void *x) {
47989 return (void *)((wxObject *) ((wxEvent *) x));
47990 }
47991 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47992 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47993 }
47994 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47995 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47996 }
47997 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47998 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47999 }
48000 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
48001 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
48002 }
48003 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
48004 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
48005 }
48006 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
48007 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
48008 }
48009 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
48010 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
48011 }
48012 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
48013 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
48014 }
48015 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
48016 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
48017 }
48018 static void *_p_wxControlTo_p_wxObject(void *x) {
48019 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
48020 }
48021 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
48022 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
48023 }
48024 static void *_p_wxFSFileTo_p_wxObject(void *x) {
48025 return (void *)((wxObject *) ((wxFSFile *) x));
48026 }
48027 static void *_p_wxPySizerTo_p_wxObject(void *x) {
48028 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
48029 }
48030 static void *_p_wxPyEventTo_p_wxObject(void *x) {
48031 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
48032 }
48033 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
48034 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
48035 }
48036 static void *_p_wxShowEventTo_p_wxObject(void *x) {
48037 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
48038 }
48039 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
48040 return (void *)((wxObject *) ((wxMenuItem *) x));
48041 }
48042 static void *_p_wxDateEventTo_p_wxObject(void *x) {
48043 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
48044 }
48045 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
48046 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
48047 }
48048 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
48049 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
48050 }
48051 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
48052 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
48053 }
48054 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
48055 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
48056 }
48057 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
48058 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
48059 }
48060 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
48061 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
48062 }
48063 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
48064 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
48065 }
48066 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
48067 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
48068 }
48069 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
48070 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
48071 }
48072 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
48073 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
48074 }
48075 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
48076 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
48077 }
48078 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
48079 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
48080 }
48081 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
48082 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
48083 }
48084 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
48085 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
48086 }
48087 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
48088 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
48089 }
48090 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
48091 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
48092 }
48093 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
48094 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
48095 }
48096 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
48097 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
48098 }
48099 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
48100 return (void *)((wxObject *) ((wxImageHandler *) x));
48101 }
48102 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
48103 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
48104 }
48105 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
48106 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
48107 }
48108 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
48109 return (void *)((wxObject *) ((wxEvtHandler *) x));
48110 }
48111 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
48112 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
48113 }
48114 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
48115 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
48116 }
48117 static void *_p_wxImageTo_p_wxObject(void *x) {
48118 return (void *)((wxObject *) ((wxImage *) x));
48119 }
48120 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
48121 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
48122 }
48123 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
48124 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48125 }
48126 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
48127 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
48128 }
48129 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
48130 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
48131 }
48132 static void *_p_wxWindowTo_p_wxObject(void *x) {
48133 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
48134 }
48135 static void *_p_wxMenuTo_p_wxObject(void *x) {
48136 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
48137 }
48138 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
48139 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
48140 }
48141 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
48142 return (void *)((wxObject *) ((wxFileSystem *) x));
48143 }
48144 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
48145 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
48146 }
48147 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
48148 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
48149 }
48150 static void *_p_wxPyAppTo_p_wxObject(void *x) {
48151 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
48152 }
48153 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
48154 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
48155 }
48156 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
48157 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
48158 }
48159 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
48160 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
48161 }
48162 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
48163 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
48164 }
48165 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
48166 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
48167 }
48168 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
48169 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
48170 }
48171 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
48172 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
48173 }
48174 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
48175 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
48176 }
48177 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
48178 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
48179 }
48180 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
48181 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
48182 }
48183 static void *_p_wxValidatorTo_p_wxObject(void *x) {
48184 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
48185 }
48186 static void *_p_wxControlTo_p_wxWindow(void *x) {
48187 return (void *)((wxWindow *) ((wxControl *) x));
48188 }
48189 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
48190 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
48191 }
48192 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
48193 return (void *)((wxWindow *) ((wxMenuBar *) x));
48194 }
48195 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48196 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48197 }
48198 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48199 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48200 }
48201 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48202 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48203 }
48204 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48205 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48206 }
48207 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48208 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48209 }
48210 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48211 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48212 }
48213 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48214 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48215 }
48216 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48217 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48218 }
48219 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48220 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48221 }
48222 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48223 return (void *)((wxValidator *) ((wxPyValidator *) x));
48224 }
48225 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48226 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48227 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48228 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48229 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48230 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48231 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48232 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48233 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48234 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48235 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48236 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48237 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48238 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48239 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48240 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48241 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48242 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48243 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48244 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48245 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48246 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48247 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48248 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48249 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48250 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48251 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48252 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48253 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48254 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48255 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48256 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48257 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48258 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48259 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48260 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48261 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48262 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48263 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48264 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48265 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48266 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48267 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48268 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48269 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48270 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48271 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48272 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48273 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48274 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48275 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48276 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48277 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48278 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48279 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48280 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48281 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48282 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48283 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48284 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48285 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48286 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48287 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48288 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48289 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48290 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48291 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48292 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48293 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48294 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48295 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48296 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48297 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48298 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48299 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48300 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48301 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48302 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48303 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48304 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48305 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48306 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48307 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48308 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48309 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48310 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48311 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48312 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48313 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48314 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48315 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48316 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48317 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48318 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48319 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48320 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48321 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48322 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48323 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48324 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48325 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48326 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48327 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48328 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48329 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48330 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48331 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48332 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48333 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48334 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48335 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48336 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48337 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48338 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48339 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48340 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48341 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48342 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48343 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48344 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48345 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48346 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48347 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48348 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48349 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48350 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48351 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48352 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48353 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48354 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48355 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48356 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48357
48358 static swig_type_info *swig_type_initial[] = {
48359 &_swigt__p_buffer,
48360 &_swigt__p_char,
48361 &_swigt__p_form_ops_t,
48362 &_swigt__p_int,
48363 &_swigt__p_long,
48364 &_swigt__p_unsigned_char,
48365 &_swigt__p_unsigned_int,
48366 &_swigt__p_unsigned_long,
48367 &_swigt__p_wxANIHandler,
48368 &_swigt__p_wxAcceleratorEntry,
48369 &_swigt__p_wxAcceleratorTable,
48370 &_swigt__p_wxActivateEvent,
48371 &_swigt__p_wxAppTraits,
48372 &_swigt__p_wxArrayString,
48373 &_swigt__p_wxBMPHandler,
48374 &_swigt__p_wxBitmap,
48375 &_swigt__p_wxBoxSizer,
48376 &_swigt__p_wxButton,
48377 &_swigt__p_wxCURHandler,
48378 &_swigt__p_wxCaret,
48379 &_swigt__p_wxChildFocusEvent,
48380 &_swigt__p_wxCloseEvent,
48381 &_swigt__p_wxColour,
48382 &_swigt__p_wxCommandEvent,
48383 &_swigt__p_wxContextMenuEvent,
48384 &_swigt__p_wxControl,
48385 &_swigt__p_wxControlWithItems,
48386 &_swigt__p_wxCursor,
48387 &_swigt__p_wxDC,
48388 &_swigt__p_wxDateEvent,
48389 &_swigt__p_wxDateTime,
48390 &_swigt__p_wxDisplayChangedEvent,
48391 &_swigt__p_wxDropFilesEvent,
48392 &_swigt__p_wxDuplexMode,
48393 &_swigt__p_wxEraseEvent,
48394 &_swigt__p_wxEvent,
48395 &_swigt__p_wxEventLoop,
48396 &_swigt__p_wxEventLoopActivator,
48397 &_swigt__p_wxEvtHandler,
48398 &_swigt__p_wxFSFile,
48399 &_swigt__p_wxFileSystem,
48400 &_swigt__p_wxFileSystemHandler,
48401 &_swigt__p_wxFlexGridSizer,
48402 &_swigt__p_wxFocusEvent,
48403 &_swigt__p_wxFont,
48404 &_swigt__p_wxFrame,
48405 &_swigt__p_wxGBPosition,
48406 &_swigt__p_wxGBSizerItem,
48407 &_swigt__p_wxGBSpan,
48408 &_swigt__p_wxGIFHandler,
48409 &_swigt__p_wxGridBagSizer,
48410 &_swigt__p_wxGridSizer,
48411 &_swigt__p_wxICOHandler,
48412 &_swigt__p_wxIconizeEvent,
48413 &_swigt__p_wxIdleEvent,
48414 &_swigt__p_wxImage,
48415 &_swigt__p_wxImageHandler,
48416 &_swigt__p_wxImageHistogram,
48417 &_swigt__p_wxImage_HSVValue,
48418 &_swigt__p_wxImage_RGBValue,
48419 &_swigt__p_wxIndividualLayoutConstraint,
48420 &_swigt__p_wxInitDialogEvent,
48421 &_swigt__p_wxInputStream,
48422 &_swigt__p_wxInternetFSHandler,
48423 &_swigt__p_wxItemContainer,
48424 &_swigt__p_wxJPEGHandler,
48425 &_swigt__p_wxKeyEvent,
48426 &_swigt__p_wxLayoutConstraints,
48427 &_swigt__p_wxMaximizeEvent,
48428 &_swigt__p_wxMemoryFSHandler,
48429 &_swigt__p_wxMenu,
48430 &_swigt__p_wxMenuBar,
48431 &_swigt__p_wxMenuBarBase,
48432 &_swigt__p_wxMenuEvent,
48433 &_swigt__p_wxMenuItem,
48434 &_swigt__p_wxMouseCaptureChangedEvent,
48435 &_swigt__p_wxMouseEvent,
48436 &_swigt__p_wxMoveEvent,
48437 &_swigt__p_wxNavigationKeyEvent,
48438 &_swigt__p_wxNcPaintEvent,
48439 &_swigt__p_wxNotifyEvent,
48440 &_swigt__p_wxObject,
48441 &_swigt__p_wxOutputStream,
48442 &_swigt__p_wxPCXHandler,
48443 &_swigt__p_wxPNGHandler,
48444 &_swigt__p_wxPNMHandler,
48445 &_swigt__p_wxPaintEvent,
48446 &_swigt__p_wxPaletteChangedEvent,
48447 &_swigt__p_wxPaperSize,
48448 &_swigt__p_wxPoint,
48449 &_swigt__p_wxPoint2D,
48450 &_swigt__p_wxPropagateOnce,
48451 &_swigt__p_wxPropagationDisabler,
48452 &_swigt__p_wxPyApp,
48453 &_swigt__p_wxPyCommandEvent,
48454 &_swigt__p_wxPyDropTarget,
48455 &_swigt__p_wxPyEvent,
48456 &_swigt__p_wxPyFileSystemHandler,
48457 &_swigt__p_wxPyImageHandler,
48458 &_swigt__p_wxPyInputStream,
48459 &_swigt__p_wxPySizer,
48460 &_swigt__p_wxPyValidator,
48461 &_swigt__p_wxQuantize,
48462 &_swigt__p_wxQueryNewPaletteEvent,
48463 &_swigt__p_wxRealPoint,
48464 &_swigt__p_wxRect,
48465 &_swigt__p_wxRegion,
48466 &_swigt__p_wxScrollEvent,
48467 &_swigt__p_wxScrollWinEvent,
48468 &_swigt__p_wxSetCursorEvent,
48469 &_swigt__p_wxShowEvent,
48470 &_swigt__p_wxSize,
48471 &_swigt__p_wxSizeEvent,
48472 &_swigt__p_wxSizer,
48473 &_swigt__p_wxSizerItem,
48474 &_swigt__p_wxStaticBox,
48475 &_swigt__p_wxStaticBoxSizer,
48476 &_swigt__p_wxStdDialogButtonSizer,
48477 &_swigt__p_wxSysColourChangedEvent,
48478 &_swigt__p_wxTIFFHandler,
48479 &_swigt__p_wxToolTip,
48480 &_swigt__p_wxUpdateUIEvent,
48481 &_swigt__p_wxValidator,
48482 &_swigt__p_wxVisualAttributes,
48483 &_swigt__p_wxWindow,
48484 &_swigt__p_wxWindowCreateEvent,
48485 &_swigt__p_wxWindowDestroyEvent,
48486 &_swigt__p_wxXPMHandler,
48487 &_swigt__p_wxZipFSHandler,
48488 &_swigt__ptrdiff_t,
48489 &_swigt__std__ptrdiff_t,
48490 &_swigt__unsigned_int,
48491 };
48492
48493 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48494 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48495 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48496 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48497 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48498 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48499 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48500 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48501 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48502 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48503 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48504 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48505 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48506 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48507 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}};
48508 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48509 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}};
48510 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48511 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}};
48512 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48513 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48514 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48515 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48516 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}};
48517 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48518 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}};
48519 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48520 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48521 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48522 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48523 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48524 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48525 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48526 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48527 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48528 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}};
48529 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48530 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48531 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}};
48532 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48533 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48534 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}};
48535 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}};
48536 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48537 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48538 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48539 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48540 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48541 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48542 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48543 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48544 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}};
48545 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}};
48546 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48547 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48548 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48549 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}};
48550 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48551 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48552 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48553 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48554 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48555 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48556 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48557 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}};
48558 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48559 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48560 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48561 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48562 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48563 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48564 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48565 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48566 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48567 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48568 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48569 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48570 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48571 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48572 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48573 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48574 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}};
48575 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48576 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48577 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48578 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48579 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48580 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48581 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48582 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48583 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48584 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48585 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48586 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48587 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48588 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48589 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48590 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48591 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48592 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48593 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48594 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48595 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48596 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48597 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48598 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48599 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48600 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48601 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48602 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48603 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48604 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48605 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48606 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}};
48607 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}};
48608 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48609 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48610 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48611 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48612 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48613 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48614 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48615 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}};
48616 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48617 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}};
48618 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48619 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48620 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48621 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48622 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48623 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48624 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48625
48626 static swig_cast_info *swig_cast_initial[] = {
48627 _swigc__p_buffer,
48628 _swigc__p_char,
48629 _swigc__p_form_ops_t,
48630 _swigc__p_int,
48631 _swigc__p_long,
48632 _swigc__p_unsigned_char,
48633 _swigc__p_unsigned_int,
48634 _swigc__p_unsigned_long,
48635 _swigc__p_wxANIHandler,
48636 _swigc__p_wxAcceleratorEntry,
48637 _swigc__p_wxAcceleratorTable,
48638 _swigc__p_wxActivateEvent,
48639 _swigc__p_wxAppTraits,
48640 _swigc__p_wxArrayString,
48641 _swigc__p_wxBMPHandler,
48642 _swigc__p_wxBitmap,
48643 _swigc__p_wxBoxSizer,
48644 _swigc__p_wxButton,
48645 _swigc__p_wxCURHandler,
48646 _swigc__p_wxCaret,
48647 _swigc__p_wxChildFocusEvent,
48648 _swigc__p_wxCloseEvent,
48649 _swigc__p_wxColour,
48650 _swigc__p_wxCommandEvent,
48651 _swigc__p_wxContextMenuEvent,
48652 _swigc__p_wxControl,
48653 _swigc__p_wxControlWithItems,
48654 _swigc__p_wxCursor,
48655 _swigc__p_wxDC,
48656 _swigc__p_wxDateEvent,
48657 _swigc__p_wxDateTime,
48658 _swigc__p_wxDisplayChangedEvent,
48659 _swigc__p_wxDropFilesEvent,
48660 _swigc__p_wxDuplexMode,
48661 _swigc__p_wxEraseEvent,
48662 _swigc__p_wxEvent,
48663 _swigc__p_wxEventLoop,
48664 _swigc__p_wxEventLoopActivator,
48665 _swigc__p_wxEvtHandler,
48666 _swigc__p_wxFSFile,
48667 _swigc__p_wxFileSystem,
48668 _swigc__p_wxFileSystemHandler,
48669 _swigc__p_wxFlexGridSizer,
48670 _swigc__p_wxFocusEvent,
48671 _swigc__p_wxFont,
48672 _swigc__p_wxFrame,
48673 _swigc__p_wxGBPosition,
48674 _swigc__p_wxGBSizerItem,
48675 _swigc__p_wxGBSpan,
48676 _swigc__p_wxGIFHandler,
48677 _swigc__p_wxGridBagSizer,
48678 _swigc__p_wxGridSizer,
48679 _swigc__p_wxICOHandler,
48680 _swigc__p_wxIconizeEvent,
48681 _swigc__p_wxIdleEvent,
48682 _swigc__p_wxImage,
48683 _swigc__p_wxImageHandler,
48684 _swigc__p_wxImageHistogram,
48685 _swigc__p_wxImage_HSVValue,
48686 _swigc__p_wxImage_RGBValue,
48687 _swigc__p_wxIndividualLayoutConstraint,
48688 _swigc__p_wxInitDialogEvent,
48689 _swigc__p_wxInputStream,
48690 _swigc__p_wxInternetFSHandler,
48691 _swigc__p_wxItemContainer,
48692 _swigc__p_wxJPEGHandler,
48693 _swigc__p_wxKeyEvent,
48694 _swigc__p_wxLayoutConstraints,
48695 _swigc__p_wxMaximizeEvent,
48696 _swigc__p_wxMemoryFSHandler,
48697 _swigc__p_wxMenu,
48698 _swigc__p_wxMenuBar,
48699 _swigc__p_wxMenuBarBase,
48700 _swigc__p_wxMenuEvent,
48701 _swigc__p_wxMenuItem,
48702 _swigc__p_wxMouseCaptureChangedEvent,
48703 _swigc__p_wxMouseEvent,
48704 _swigc__p_wxMoveEvent,
48705 _swigc__p_wxNavigationKeyEvent,
48706 _swigc__p_wxNcPaintEvent,
48707 _swigc__p_wxNotifyEvent,
48708 _swigc__p_wxObject,
48709 _swigc__p_wxOutputStream,
48710 _swigc__p_wxPCXHandler,
48711 _swigc__p_wxPNGHandler,
48712 _swigc__p_wxPNMHandler,
48713 _swigc__p_wxPaintEvent,
48714 _swigc__p_wxPaletteChangedEvent,
48715 _swigc__p_wxPaperSize,
48716 _swigc__p_wxPoint,
48717 _swigc__p_wxPoint2D,
48718 _swigc__p_wxPropagateOnce,
48719 _swigc__p_wxPropagationDisabler,
48720 _swigc__p_wxPyApp,
48721 _swigc__p_wxPyCommandEvent,
48722 _swigc__p_wxPyDropTarget,
48723 _swigc__p_wxPyEvent,
48724 _swigc__p_wxPyFileSystemHandler,
48725 _swigc__p_wxPyImageHandler,
48726 _swigc__p_wxPyInputStream,
48727 _swigc__p_wxPySizer,
48728 _swigc__p_wxPyValidator,
48729 _swigc__p_wxQuantize,
48730 _swigc__p_wxQueryNewPaletteEvent,
48731 _swigc__p_wxRealPoint,
48732 _swigc__p_wxRect,
48733 _swigc__p_wxRegion,
48734 _swigc__p_wxScrollEvent,
48735 _swigc__p_wxScrollWinEvent,
48736 _swigc__p_wxSetCursorEvent,
48737 _swigc__p_wxShowEvent,
48738 _swigc__p_wxSize,
48739 _swigc__p_wxSizeEvent,
48740 _swigc__p_wxSizer,
48741 _swigc__p_wxSizerItem,
48742 _swigc__p_wxStaticBox,
48743 _swigc__p_wxStaticBoxSizer,
48744 _swigc__p_wxStdDialogButtonSizer,
48745 _swigc__p_wxSysColourChangedEvent,
48746 _swigc__p_wxTIFFHandler,
48747 _swigc__p_wxToolTip,
48748 _swigc__p_wxUpdateUIEvent,
48749 _swigc__p_wxValidator,
48750 _swigc__p_wxVisualAttributes,
48751 _swigc__p_wxWindow,
48752 _swigc__p_wxWindowCreateEvent,
48753 _swigc__p_wxWindowDestroyEvent,
48754 _swigc__p_wxXPMHandler,
48755 _swigc__p_wxZipFSHandler,
48756 _swigc__ptrdiff_t,
48757 _swigc__std__ptrdiff_t,
48758 _swigc__unsigned_int,
48759 };
48760
48761
48762 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48763
48764 static swig_const_info swig_const_table[] = {
48765 {0, 0, 0, 0.0, 0, 0}};
48766
48767 #ifdef __cplusplus
48768 }
48769 #endif
48770 /*************************************************************************
48771 * Type initialization:
48772 * This problem is tough by the requirement that no dynamic
48773 * memory is used. Also, since swig_type_info structures store pointers to
48774 * swig_cast_info structures and swig_cast_info structures store pointers back
48775 * to swig_type_info structures, we need some lookup code at initialization.
48776 * The idea is that swig generates all the structures that are needed.
48777 * The runtime then collects these partially filled structures.
48778 * The SWIG_InitializeModule function takes these initial arrays out of
48779 * swig_module, and does all the lookup, filling in the swig_module.types
48780 * array with the correct data and linking the correct swig_cast_info
48781 * structures together.
48782
48783 * The generated swig_type_info structures are assigned staticly to an initial
48784 * array. We just loop though that array, and handle each type individually.
48785 * First we lookup if this type has been already loaded, and if so, use the
48786 * loaded structure instead of the generated one. Then we have to fill in the
48787 * cast linked list. The cast data is initially stored in something like a
48788 * two-dimensional array. Each row corresponds to a type (there are the same
48789 * number of rows as there are in the swig_type_initial array). Each entry in
48790 * a column is one of the swig_cast_info structures for that type.
48791 * The cast_initial array is actually an array of arrays, because each row has
48792 * a variable number of columns. So to actually build the cast linked list,
48793 * we find the array of casts associated with the type, and loop through it
48794 * adding the casts to the list. The one last trick we need to do is making
48795 * sure the type pointer in the swig_cast_info struct is correct.
48796
48797 * First off, we lookup the cast->type name to see if it is already loaded.
48798 * There are three cases to handle:
48799 * 1) If the cast->type has already been loaded AND the type we are adding
48800 * casting info to has not been loaded (it is in this module), THEN we
48801 * replace the cast->type pointer with the type pointer that has already
48802 * been loaded.
48803 * 2) If BOTH types (the one we are adding casting info to, and the
48804 * cast->type) are loaded, THEN the cast info has already been loaded by
48805 * the previous module so we just ignore it.
48806 * 3) Finally, if cast->type has not already been loaded, then we add that
48807 * swig_cast_info to the linked list (because the cast->type) pointer will
48808 * be correct.
48809 **/
48810
48811 #ifdef __cplusplus
48812 extern "C" {
48813 #if 0
48814 } /* c-mode */
48815 #endif
48816 #endif
48817
48818 #if 0
48819 #define SWIGRUNTIME_DEBUG
48820 #endif
48821
48822 SWIGRUNTIME void
48823 SWIG_InitializeModule(void *clientdata) {
48824 size_t i;
48825 swig_module_info *module_head;
48826 static int init_run = 0;
48827
48828 clientdata = clientdata;
48829
48830 if (init_run) return;
48831 init_run = 1;
48832
48833 /* Initialize the swig_module */
48834 swig_module.type_initial = swig_type_initial;
48835 swig_module.cast_initial = swig_cast_initial;
48836
48837 /* Try and load any already created modules */
48838 module_head = SWIG_GetModule(clientdata);
48839 if (module_head) {
48840 swig_module.next = module_head->next;
48841 module_head->next = &swig_module;
48842 } else {
48843 /* This is the first module loaded */
48844 swig_module.next = &swig_module;
48845 SWIG_SetModule(clientdata, &swig_module);
48846 }
48847
48848 /* Now work on filling in swig_module.types */
48849 #ifdef SWIGRUNTIME_DEBUG
48850 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48851 #endif
48852 for (i = 0; i < swig_module.size; ++i) {
48853 swig_type_info *type = 0;
48854 swig_type_info *ret;
48855 swig_cast_info *cast;
48856
48857 #ifdef SWIGRUNTIME_DEBUG
48858 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48859 #endif
48860
48861 /* if there is another module already loaded */
48862 if (swig_module.next != &swig_module) {
48863 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48864 }
48865 if (type) {
48866 /* Overwrite clientdata field */
48867 #ifdef SWIGRUNTIME_DEBUG
48868 printf("SWIG_InitializeModule: found type %s\n", type->name);
48869 #endif
48870 if (swig_module.type_initial[i]->clientdata) {
48871 type->clientdata = swig_module.type_initial[i]->clientdata;
48872 #ifdef SWIGRUNTIME_DEBUG
48873 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48874 #endif
48875 }
48876 } else {
48877 type = swig_module.type_initial[i];
48878 }
48879
48880 /* Insert casting types */
48881 cast = swig_module.cast_initial[i];
48882 while (cast->type) {
48883 /* Don't need to add information already in the list */
48884 ret = 0;
48885 #ifdef SWIGRUNTIME_DEBUG
48886 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48887 #endif
48888 if (swig_module.next != &swig_module) {
48889 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48890 #ifdef SWIGRUNTIME_DEBUG
48891 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48892 #endif
48893 }
48894 if (ret) {
48895 if (type == swig_module.type_initial[i]) {
48896 #ifdef SWIGRUNTIME_DEBUG
48897 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48898 #endif
48899 cast->type = ret;
48900 ret = 0;
48901 } else {
48902 /* Check for casting already in the list */
48903 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48904 #ifdef SWIGRUNTIME_DEBUG
48905 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48906 #endif
48907 if (!ocast) ret = 0;
48908 }
48909 }
48910
48911 if (!ret) {
48912 #ifdef SWIGRUNTIME_DEBUG
48913 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48914 #endif
48915 if (type->cast) {
48916 type->cast->prev = cast;
48917 cast->next = type->cast;
48918 }
48919 type->cast = cast;
48920 }
48921 cast++;
48922 }
48923 /* Set entry in modules->types array equal to the type */
48924 swig_module.types[i] = type;
48925 }
48926 swig_module.types[i] = 0;
48927
48928 #ifdef SWIGRUNTIME_DEBUG
48929 printf("**** SWIG_InitializeModule: Cast List ******\n");
48930 for (i = 0; i < swig_module.size; ++i) {
48931 int j = 0;
48932 swig_cast_info *cast = swig_module.cast_initial[i];
48933 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48934 while (cast->type) {
48935 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48936 cast++;
48937 ++j;
48938 }
48939 printf("---- Total casts: %d\n",j);
48940 }
48941 printf("**** SWIG_InitializeModule: Cast List ******\n");
48942 #endif
48943 }
48944
48945 /* This function will propagate the clientdata field of type to
48946 * any new swig_type_info structures that have been added into the list
48947 * of equivalent types. It is like calling
48948 * SWIG_TypeClientData(type, clientdata) a second time.
48949 */
48950 SWIGRUNTIME void
48951 SWIG_PropagateClientData(void) {
48952 size_t i;
48953 swig_cast_info *equiv;
48954 static int init_run = 0;
48955
48956 if (init_run) return;
48957 init_run = 1;
48958
48959 for (i = 0; i < swig_module.size; i++) {
48960 if (swig_module.types[i]->clientdata) {
48961 equiv = swig_module.types[i]->cast;
48962 while (equiv) {
48963 if (!equiv->converter) {
48964 if (equiv->type && !equiv->type->clientdata)
48965 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
48966 }
48967 equiv = equiv->next;
48968 }
48969 }
48970 }
48971 }
48972
48973 #ifdef __cplusplus
48974 #if 0
48975 {
48976 /* c-mode */
48977 #endif
48978 }
48979 #endif
48980
48981
48982
48983 #ifdef __cplusplus
48984 extern "C" {
48985 #endif
48986
48987 /* Python-specific SWIG API */
48988 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48989 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48990 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48991
48992 /* -----------------------------------------------------------------------------
48993 * global variable support code.
48994 * ----------------------------------------------------------------------------- */
48995
48996 typedef struct swig_globalvar {
48997 char *name; /* Name of global variable */
48998 PyObject *(*get_attr)(void); /* Return the current value */
48999 int (*set_attr)(PyObject *); /* Set the value */
49000 struct swig_globalvar *next;
49001 } swig_globalvar;
49002
49003 typedef struct swig_varlinkobject {
49004 PyObject_HEAD
49005 swig_globalvar *vars;
49006 } swig_varlinkobject;
49007
49008 SWIGINTERN PyObject *
49009 swig_varlink_repr(swig_varlinkobject *v) {
49010 v = v;
49011 return PyString_FromString("<Swig global variables>");
49012 }
49013
49014 SWIGINTERN int
49015 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
49016 swig_globalvar *var;
49017 flags = flags;
49018 fprintf(fp,"Swig global variables { ");
49019 for (var = v->vars; var; var=var->next) {
49020 fprintf(fp,"%s", var->name);
49021 if (var->next) fprintf(fp,", ");
49022 }
49023 fprintf(fp," }\n");
49024 return 0;
49025 }
49026
49027 SWIGINTERN PyObject *
49028 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
49029 swig_globalvar *var = v->vars;
49030 while (var) {
49031 if (strcmp(var->name,n) == 0) {
49032 return (*var->get_attr)();
49033 }
49034 var = var->next;
49035 }
49036 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
49037 return NULL;
49038 }
49039
49040 SWIGINTERN int
49041 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
49042 swig_globalvar *var = v->vars;
49043 while (var) {
49044 if (strcmp(var->name,n) == 0) {
49045 return (*var->set_attr)(p);
49046 }
49047 var = var->next;
49048 }
49049 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
49050 return 1;
49051 }
49052
49053 SWIGINTERN PyTypeObject*
49054 swig_varlink_type(void) {
49055 static char varlink__doc__[] = "Swig var link object";
49056 static PyTypeObject varlink_type
49057 #if !defined(__cplusplus)
49058 ;
49059 static int type_init = 0;
49060 if (!type_init) {
49061 PyTypeObject tmp
49062 #endif
49063 = {
49064 PyObject_HEAD_INIT(&PyType_Type)
49065 0, /* Number of items in variable part (ob_size) */
49066 (char *)"swigvarlink", /* Type name (tp_name) */
49067 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
49068 0, /* Itemsize (tp_itemsize) */
49069 0, /* Deallocator (tp_dealloc) */
49070 (printfunc) swig_varlink_print, /* Print (tp_print) */
49071 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
49072 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
49073 0, /* tp_compare */
49074 (reprfunc) swig_varlink_repr, /* tp_repr */
49075 0, /* tp_as_number */
49076 0, /* tp_as_sequence */
49077 0, /* tp_as_mapping */
49078 0, /* tp_hash */
49079 0, /* tp_call */
49080 0, /* tp_str */
49081 0, /* tp_getattro */
49082 0, /* tp_setattro */
49083 0, /* tp_as_buffer */
49084 0, /* tp_flags */
49085 varlink__doc__, /* tp_doc */
49086 #if PY_VERSION_HEX >= 0x02000000
49087 0, /* tp_traverse */
49088 0, /* tp_clear */
49089 #endif
49090 #if PY_VERSION_HEX >= 0x02010000
49091 0, /* tp_richcompare */
49092 0, /* tp_weaklistoffset */
49093 #endif
49094 #if PY_VERSION_HEX >= 0x02020000
49095 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
49096 #endif
49097 #if PY_VERSION_HEX >= 0x02030000
49098 0, /* tp_del */
49099 #endif
49100 #ifdef COUNT_ALLOCS
49101 0,0,0,0 /* tp_alloc -> tp_next */
49102 #endif
49103 };
49104 #if !defined(__cplusplus)
49105 varlink_type = tmp;
49106 type_init = 1;
49107 }
49108 #endif
49109 return &varlink_type;
49110 }
49111
49112 /* Create a variable linking object for use later */
49113 SWIGINTERN PyObject *
49114 SWIG_Python_newvarlink(void) {
49115 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
49116 if (result) {
49117 result->vars = 0;
49118 }
49119 return ((PyObject*) result);
49120 }
49121
49122 SWIGINTERN void
49123 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
49124 swig_varlinkobject *v = (swig_varlinkobject *) p;
49125 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
49126 if (gv) {
49127 size_t size = strlen(name)+1;
49128 gv->name = (char *)malloc(size);
49129 if (gv->name) {
49130 strncpy(gv->name,name,size);
49131 gv->get_attr = get_attr;
49132 gv->set_attr = set_attr;
49133 gv->next = v->vars;
49134 }
49135 }
49136 v->vars = gv;
49137 }
49138
49139 /* -----------------------------------------------------------------------------
49140 * constants/methods manipulation
49141 * ----------------------------------------------------------------------------- */
49142
49143 /* Install Constants */
49144 SWIGINTERN void
49145 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
49146 PyObject *obj = 0;
49147 size_t i;
49148 for (i = 0; constants[i].type; ++i) {
49149 switch(constants[i].type) {
49150 case SWIG_PY_INT:
49151 obj = PyInt_FromLong(constants[i].lvalue);
49152 break;
49153 case SWIG_PY_FLOAT:
49154 obj = PyFloat_FromDouble(constants[i].dvalue);
49155 break;
49156 case SWIG_PY_STRING:
49157 if (constants[i].pvalue) {
49158 obj = PyString_FromString((char *) constants[i].pvalue);
49159 } else {
49160 Py_INCREF(Py_None);
49161 obj = Py_None;
49162 }
49163 break;
49164 case SWIG_PY_POINTER:
49165 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
49166 break;
49167 case SWIG_PY_BINARY:
49168 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
49169 break;
49170 default:
49171 obj = 0;
49172 break;
49173 }
49174 if (obj) {
49175 PyDict_SetItemString(d,constants[i].name,obj);
49176 Py_DECREF(obj);
49177 }
49178 }
49179 }
49180
49181 /* -----------------------------------------------------------------------------*/
49182 /* Fix SwigMethods to carry the callback ptrs when needed */
49183 /* -----------------------------------------------------------------------------*/
49184
49185 SWIGINTERN void
49186 SWIG_Python_FixMethods(PyMethodDef *methods,
49187 swig_const_info *const_table,
49188 swig_type_info **types,
49189 swig_type_info **types_initial) {
49190 size_t i;
49191 for (i = 0; methods[i].ml_name; ++i) {
49192 char *c = methods[i].ml_doc;
49193 if (c && (c = strstr(c, "swig_ptr: "))) {
49194 int j;
49195 swig_const_info *ci = 0;
49196 char *name = c + 10;
49197 for (j = 0; const_table[j].type; ++j) {
49198 if (strncmp(const_table[j].name, name,
49199 strlen(const_table[j].name)) == 0) {
49200 ci = &(const_table[j]);
49201 break;
49202 }
49203 }
49204 if (ci) {
49205 size_t shift = (ci->ptype) - types;
49206 swig_type_info *ty = types_initial[shift];
49207 size_t ldoc = (c - methods[i].ml_doc);
49208 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49209 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49210 if (ndoc) {
49211 char *buff = ndoc;
49212 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49213 if (ptr) {
49214 strncpy(buff, methods[i].ml_doc, ldoc);
49215 buff += ldoc;
49216 strncpy(buff, "swig_ptr: ", 10);
49217 buff += 10;
49218 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49219 methods[i].ml_doc = ndoc;
49220 }
49221 }
49222 }
49223 }
49224 }
49225 }
49226
49227 /* -----------------------------------------------------------------------------*
49228 * Initialize type list
49229 * -----------------------------------------------------------------------------*/
49230
49231 #ifdef __cplusplus
49232 }
49233 #endif
49234
49235 /* -----------------------------------------------------------------------------*
49236 * Partial Init method
49237 * -----------------------------------------------------------------------------*/
49238
49239 #ifdef __cplusplus
49240 extern "C"
49241 #endif
49242 SWIGEXPORT void SWIG_init(void) {
49243 static PyObject *SWIG_globals = 0;
49244 PyObject *m, *d;
49245 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49246
49247 /* Fix SwigMethods to carry the callback ptrs when needed */
49248 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49249
49250 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49251 d = PyModule_GetDict(m);
49252
49253 SWIG_InitializeModule(0);
49254 SWIG_InstallConstants(d,swig_const_table);
49255
49256
49257 #ifndef wxPyUSE_EXPORT
49258 // Make our API structure a CObject so other modules can import it
49259 // from this module.
49260 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49261 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49262 Py_XDECREF(cobj);
49263 #endif
49264
49265 {
49266 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49429 }
49430 {
49431 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49432 }
49433 {
49434 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49435 }
49436 {
49437 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49438 }
49439 {
49440 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49597 }
49598 {
49599 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49600 }
49601 {
49602 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49603 }
49604 {
49605 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49606 }
49607 {
49608 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49615 }
49616 {
49617 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49618 }
49619 {
49620 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49621 }
49622 {
49623 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49624 }
49625 {
49626 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49627 }
49628 {
49629 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49630 }
49631 {
49632 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49633 }
49634 {
49635 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49636 }
49637 {
49638 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49639 }
49640 {
49641 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49687 }
49688 {
49689 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49690 }
49691 {
49692 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49693 }
49694 {
49695 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49696 }
49697 {
49698 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49699 }
49700 {
49701 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49702 }
49703 {
49704 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49705 }
49706 {
49707 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49708 }
49709 {
49710 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49711 }
49712 {
49713 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49714 }
49715 {
49716 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49717 }
49718 {
49719 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49720 }
49721 {
49722 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49723 }
49724 {
49725 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49726 }
49727 {
49728 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49729 }
49730 {
49731 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49732 }
49733 {
49734 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49735 }
49736 {
49737 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49738 }
49739 {
49740 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49741 }
49742 {
49743 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49744 }
49745 {
49746 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49747 }
49748 {
49749 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49750 }
49751 {
49752 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49753 }
49754 {
49755 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49756 }
49757 {
49758 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49759 }
49760 {
49761 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49762 }
49763 {
49764 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49765 }
49766 {
49767 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49768 }
49769 {
49770 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49771 }
49772 {
49773 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49774 }
49775 {
49776 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49777 }
49778 {
49779 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49780 }
49781 {
49782 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49783 }
49784 {
49785 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49789 }
49790 {
49791 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49801 }
49802 {
49803 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49804 }
49805 {
49806 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49822 }
49823 {
49824 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49825 }
49826 {
49827 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49828 }
49829 {
49830 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49831 }
49832 {
49833 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49834 }
49835 {
49836 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49837 }
49838 {
49839 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49840 }
49841 {
49842 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49843 }
49844 {
49845 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49846 }
49847 {
49848 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49849 }
49850 {
49851 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49852 }
49853 {
49854 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49855 }
49856 {
49857 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49858 }
49859 {
49860 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49861 }
49862 {
49863 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49864 }
49865 {
49866 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49867 }
49868 {
49869 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49870 }
49871 {
49872 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49873 }
49874 {
49875 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49876 }
49877 {
49878 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49879 }
49880 {
49881 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49882 }
49883 {
49884 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49885 }
49886 {
49887 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49888 }
49889 {
49890 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49891 }
49892 {
49893 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49894 }
49895 {
49896 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49897 }
49898 {
49899 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49900 }
49901 {
49902 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49903 }
49904 {
49905 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49906 }
49907 {
49908 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49909 }
49910 {
49911 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49912 }
49913 {
49914 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49915 }
49916 {
49917 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49918 }
49919 {
49920 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49921 }
49922 {
49923 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49924 }
49925 {
49926 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49927 }
49928 {
49929 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49930 }
49931 {
49932 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49933 }
49934 {
49935 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49936 }
49937 {
49938 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
49939 }
49940 {
49941 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
49942 }
49943 {
49944 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
49945 }
49946 {
49947 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
49948 }
49949 {
49950 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
49951 }
49952 {
49953 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
49954 }
49955 {
49956 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
49957 }
49958 {
49959 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
49960 }
49961 {
49962 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
49963 }
49964 {
49965 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
49966 }
49967 {
49968 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
49969 }
49970 {
49971 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
49972 }
49973 {
49974 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
49975 }
49976 {
49977 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
49978 }
49979 {
49980 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
49981 }
49982 {
49983 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
49984 }
49985 {
49986 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
49987 }
49988 {
49989 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
49990 }
49991 {
49992 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
49993 }
49994 {
49995 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
49996 }
49997 {
49998 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
49999 }
50000 {
50001 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
50002 }
50003 {
50004 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
50005 }
50006 {
50007 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
50008 }
50009 {
50010 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
50011 }
50012 {
50013 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
50014 }
50015 {
50016 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
50017 }
50018 {
50019 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
50020 }
50021 {
50022 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
50023 }
50024 {
50025 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
50026 }
50027 {
50028 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
50029 }
50030 {
50031 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
50032 }
50033 {
50034 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
50035 }
50036 {
50037 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
50038 }
50039 {
50040 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
50041 }
50042 {
50043 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
50044 }
50045 {
50046 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
50047 }
50048 {
50049 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
50050 }
50051 {
50052 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
50053 }
50054 {
50055 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
50056 }
50057 {
50058 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
50059 }
50060 {
50061 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
50062 }
50063 {
50064 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
50065 }
50066 {
50067 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
50068 }
50069 {
50070 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
50071 }
50072 {
50073 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
50074 }
50075 {
50076 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
50077 }
50078 {
50079 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
50080 }
50081 {
50082 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
50083 }
50084 {
50085 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
50086 }
50087 {
50088 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
50089 }
50090 {
50091 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
50092 }
50093 {
50094 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
50095 }
50096 {
50097 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
50098 }
50099 {
50100 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
50101 }
50102 {
50103 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
50104 }
50105 {
50106 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
50107 }
50108 {
50109 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
50110 }
50111 {
50112 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
50113 }
50114 {
50115 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
50116 }
50117 {
50118 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
50119 }
50120 {
50121 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
50122 }
50123 {
50124 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
50125 }
50126 {
50127 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
50128 }
50129 {
50130 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
50131 }
50132 {
50133 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
50134 }
50135 {
50136 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
50137 }
50138 {
50139 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
50140 }
50141 {
50142 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
50143 }
50144 {
50145 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
50146 }
50147 {
50148 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
50149 }
50150 {
50151 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
50152 }
50153 {
50154 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
50155 }
50156 {
50157 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
50158 }
50159 {
50160 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
50161 }
50162 {
50163 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
50164 }
50165 {
50166 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
50167 }
50168 {
50169 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
50170 }
50171 {
50172 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
50173 }
50174 {
50175 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
50176 }
50177 {
50178 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
50179 }
50180 {
50181 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
50182 }
50183 {
50184 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
50185 }
50186 {
50187 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
50188 }
50189 {
50190 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
50191 }
50192 {
50193 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
50194 }
50195 {
50196 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50197 }
50198 {
50199 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50200 }
50201 {
50202 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50203 }
50204 {
50205 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50206 }
50207 {
50208 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50209 }
50210 {
50211 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50212 }
50213 {
50214 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50215 }
50216 {
50217 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50218 }
50219 {
50220 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50221 }
50222 {
50223 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50224 }
50225 {
50226 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50227 }
50228 {
50229 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50230 }
50231 {
50232 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50233 }
50234 {
50235 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50236 }
50237 {
50238 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50239 }
50240 {
50241 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50242 }
50243 {
50244 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50245 }
50246 {
50247 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50248 }
50249 {
50250 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50251 }
50252 {
50253 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50254 }
50255 {
50256 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50257 }
50258 {
50259 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50260 }
50261 {
50262 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50263 }
50264 {
50265 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50266 }
50267 {
50268 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50269 }
50270 {
50271 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50272 }
50273 {
50274 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50275 }
50276 {
50277 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50278 }
50279 {
50280 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50281 }
50282 {
50283 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50284 }
50285 {
50286 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50287 }
50288 {
50289 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50290 }
50291 {
50292 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50293 }
50294 {
50295 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50296 }
50297 {
50298 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50299 }
50300 {
50301 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50302 }
50303 {
50304 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50305 }
50306 {
50307 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50308 }
50309 {
50310 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50311 }
50312 {
50313 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50314 }
50315 {
50316 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50317 }
50318 {
50319 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50320 }
50321 {
50322 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50323 }
50324 {
50325 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50326 }
50327 {
50328 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50329 }
50330 {
50331 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50332 }
50333 {
50334 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50335 }
50336 {
50337 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50338 }
50339 {
50340 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50341 }
50342 {
50343 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50344 }
50345 {
50346 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50347 }
50348 {
50349 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50350 }
50351 {
50352 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50353 }
50354 {
50355 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50356 }
50357 {
50358 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50359 }
50360 {
50361 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50362 }
50363 {
50364 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50365 }
50366 {
50367 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50368 }
50369 {
50370 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50371 }
50372 {
50373 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50374 }
50375 {
50376 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50377 }
50378 {
50379 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50380 }
50381 {
50382 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50383 }
50384 {
50385 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50386 }
50387 {
50388 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50389 }
50390 {
50391 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50392 }
50393 {
50394 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50395 }
50396 {
50397 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50398 }
50399 {
50400 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50401 }
50402 {
50403 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50404 }
50405 {
50406 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50407 }
50408 {
50409 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50410 }
50411 {
50412 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50413 }
50414 {
50415 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50416 }
50417 {
50418 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50419 }
50420 {
50421 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50422 }
50423 {
50424 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50425 }
50426 {
50427 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50428 }
50429 {
50430 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50431 }
50432 {
50433 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50434 }
50435 {
50436 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50437 }
50438 {
50439 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50440 }
50441 {
50442 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50443 }
50444 {
50445 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50446 }
50447 {
50448 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50449 }
50450 {
50451 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50452 }
50453 {
50454 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50455 }
50456 {
50457 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50458 }
50459 {
50460 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50461 }
50462 {
50463 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50464 }
50465 {
50466 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50467 }
50468 {
50469 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50470 }
50471 {
50472 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50473 }
50474 {
50475 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50476 }
50477 {
50478 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50479 }
50480 {
50481 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50482 }
50483 {
50484 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50485 }
50486 {
50487 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50488 }
50489 {
50490 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50491 }
50492 {
50493 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50494 }
50495 {
50496 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50497 }
50498 {
50499 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50500 }
50501 {
50502 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50503 }
50504 {
50505 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50506 }
50507 {
50508 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50509 }
50510 {
50511 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50512 }
50513 {
50514 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50515 }
50516 {
50517 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50518 }
50519 {
50520 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50521 }
50522 {
50523 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50524 }
50525 {
50526 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50527 }
50528 {
50529 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50530 }
50531 {
50532 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50533 }
50534 {
50535 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50536 }
50537 {
50538 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50539 }
50540 {
50541 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50542 }
50543 {
50544 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50545 }
50546 {
50547 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50548 }
50549 {
50550 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50551 }
50552 {
50553 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50554 }
50555 {
50556 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50557 }
50558 {
50559 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50560 }
50561 {
50562 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50563 }
50564 {
50565 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50566 }
50567 {
50568 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50569 }
50570 {
50571 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50572 }
50573 {
50574 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50575 }
50576 {
50577 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50578 }
50579 {
50580 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50581 }
50582 {
50583 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50584 }
50585 {
50586 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50587 }
50588 {
50589 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50590 }
50591 {
50592 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50593 }
50594 {
50595 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50596 }
50597 {
50598 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50599 }
50600 {
50601 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50602 }
50603 {
50604 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50605 }
50606 {
50607 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50608 }
50609 {
50610 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50611 }
50612 {
50613 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50614 }
50615 {
50616 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50617 }
50618 {
50619 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50620 }
50621 {
50622 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50623 }
50624 {
50625 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50626 }
50627 {
50628 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50629 }
50630 {
50631 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50632 }
50633 {
50634 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50635 }
50636 {
50637 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50638 }
50639 {
50640 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50641 }
50642 {
50643 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50644 }
50645 {
50646 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50647 }
50648 {
50649 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50650 }
50651 {
50652 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50653 }
50654 {
50655 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50656 }
50657 {
50658 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50659 }
50660 {
50661 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50662 }
50663 {
50664 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50665 }
50666 {
50667 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50668 }
50669 {
50670 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50671 }
50672 {
50673 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50674 }
50675 {
50676 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50677 }
50678 {
50679 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50680 }
50681 {
50682 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50683 }
50684 {
50685 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50686 }
50687 {
50688 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50689 }
50690 {
50691 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50692 }
50693 {
50694 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50695 }
50696 {
50697 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50698 }
50699 {
50700 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50701 }
50702 {
50703 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50704 }
50705 {
50706 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50707 }
50708 {
50709 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50710 }
50711 {
50712 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50713 }
50714 {
50715 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50716 }
50717 {
50718 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50719 }
50720 {
50721 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50722 }
50723 {
50724 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50725 }
50726 {
50727 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50728 }
50729 {
50730 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50731 }
50732 {
50733 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50734 }
50735 {
50736 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50737 }
50738 {
50739 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50740 }
50741 {
50742 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50743 }
50744 {
50745 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50746 }
50747 {
50748 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50749 }
50750 {
50751 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50752 }
50753 {
50754 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50755 }
50756 {
50757 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50758 }
50759 {
50760 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50761 }
50762 {
50763 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50764 }
50765 {
50766 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50767 }
50768 {
50769 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50770 }
50771 {
50772 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50773 }
50774 {
50775 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50776 }
50777 {
50778 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50779 }
50780 {
50781 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50782 }
50783 {
50784 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50785 }
50786 {
50787 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50788 }
50789 {
50790 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50791 }
50792 {
50793 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50794 }
50795 {
50796 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50797 }
50798 {
50799 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50800 }
50801 {
50802 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50803 }
50804 {
50805 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50806 }
50807 {
50808 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50809 }
50810 {
50811 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50812 }
50813 {
50814 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50815 }
50816 {
50817 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50818 }
50819 {
50820 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50821 }
50822 {
50823 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50824 }
50825 {
50826 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50827 }
50828 {
50829 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50830 }
50831 {
50832 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50833 }
50834 {
50835 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50836 }
50837 {
50838 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50839 }
50840 {
50841 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50842 }
50843 {
50844 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50845 }
50846 {
50847 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50848 }
50849 {
50850 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50851 }
50852 {
50853 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50854 }
50855 {
50856 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50857 }
50858 {
50859 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50860 }
50861 {
50862 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50863 }
50864 {
50865 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50866 }
50867 {
50868 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50869 }
50870 {
50871 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50872 }
50873 {
50874 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50875 }
50876 {
50877 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50878 }
50879 {
50880 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50881 }
50882 {
50883 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50884 }
50885 {
50886 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50887 }
50888 {
50889 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50890 }
50891 {
50892 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50893 }
50894 {
50895 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50896 }
50897 {
50898 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50899 }
50900 {
50901 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50902 }
50903 {
50904 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50905 }
50906 {
50907 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50908 }
50909 {
50910 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50911 }
50912 {
50913 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50914 }
50915 {
50916 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50917 }
50918 {
50919 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50920 }
50921 {
50922 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50923 }
50924 {
50925 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50926 }
50927 {
50928 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50929 }
50930 {
50931 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50932 }
50933 {
50934 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50935 }
50936 {
50937 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
50938 }
50939 {
50940 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
50941 }
50942 {
50943 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
50944 }
50945 {
50946 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
50947 }
50948 {
50949 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
50950 }
50951 {
50952 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
50953 }
50954 {
50955 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
50956 }
50957 {
50958 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
50959 }
50960 {
50961 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
50962 }
50963 {
50964 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
50965 }
50966 {
50967 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
50968 }
50969 {
50970 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
50971 }
50972 {
50973 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
50974 }
50975 {
50976 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
50977 }
50978 {
50979 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
50980 }
50981 {
50982 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
50983 }
50984 {
50985 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
50986 }
50987 {
50988 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
50989 }
50990 {
50991 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
50992 }
50993 {
50994 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
50995 }
50996 {
50997 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
50998 }
50999 {
51000 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
51001 }
51002 {
51003 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
51004 }
51005 {
51006 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
51007 }
51008 {
51009 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
51010 }
51011 {
51012 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
51013 }
51014 {
51015 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
51016 }
51017 {
51018 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
51019 }
51020 {
51021 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
51022 }
51023 {
51024 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
51025 }
51026 {
51027 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
51028 }
51029 {
51030 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
51031 }
51032 {
51033 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
51034 }
51035 {
51036 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
51037 }
51038 {
51039 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
51040 }
51041 {
51042 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
51043 }
51044 {
51045 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
51046 }
51047 {
51048 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
51049 }
51050 {
51051 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
51052 }
51053 {
51054 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
51055 }
51056 {
51057 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
51058 }
51059 {
51060 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
51061 }
51062 {
51063 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
51064 }
51065 {
51066 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
51067 }
51068 {
51069 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
51070 }
51071 {
51072 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
51073 }
51074 {
51075 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
51076 }
51077 {
51078 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
51079 }
51080 {
51081 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
51082 }
51083 {
51084 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
51085 }
51086 {
51087 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
51088 }
51089 {
51090 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
51091 }
51092 {
51093 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
51094 }
51095 {
51096 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
51097 }
51098 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
51099 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
51100 {
51101 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
51102 }
51103 {
51104 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
51105 }
51106 {
51107 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
51108 }
51109 {
51110 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
51111 }
51112 {
51113 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
51114 }
51115 {
51116 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
51117 }
51118 {
51119 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
51120 }
51121 {
51122 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
51123 }
51124 {
51125 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
51126 }
51127 {
51128 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
51129 }
51130 {
51131 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
51132 }
51133 {
51134 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
51135 }
51136 {
51137 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
51138 }
51139 {
51140 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
51141 }
51142 {
51143 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
51144 }
51145 {
51146 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
51147 }
51148 {
51149 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
51150 }
51151 {
51152 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
51153 }
51154 {
51155 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
51156 }
51157 {
51158 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
51159 }
51160 {
51161 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
51162 }
51163 {
51164 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
51165 }
51166 {
51167 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
51168 }
51169 {
51170 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
51171 }
51172 {
51173 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
51174 }
51175 {
51176 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
51177 }
51178 {
51179 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
51180 }
51181 {
51182 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
51183 }
51184 {
51185 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
51186 }
51187 {
51188 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
51189 }
51190 {
51191 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
51192 }
51193 {
51194 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51195 }
51196 {
51197 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51198 }
51199 {
51200 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51201 }
51202 {
51203 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51204 }
51205 {
51206 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51207 }
51208 {
51209 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51210 }
51211 {
51212 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51213 }
51214 {
51215 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51216 }
51217 {
51218 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51219 }
51220 {
51221 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51222 }
51223 {
51224 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51225 }
51226 {
51227 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51228 }
51229 {
51230 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51231 }
51232 {
51233 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51234 }
51235 {
51236 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51237 }
51238 {
51239 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51240 }
51241 {
51242 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51243 }
51244 {
51245 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51246 }
51247 {
51248 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51249 }
51250 {
51251 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51252 }
51253 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51254 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51255 {
51256 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51257 }
51258 {
51259 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51260 }
51261 {
51262 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51263 }
51264
51265 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51266
51267
51268 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51269
51270 {
51271 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51272 }
51273 {
51274 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51275 }
51276 {
51277 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51278 }
51279 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51280 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51281 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51282 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51283 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51284 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51285 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51286 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51287 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51288 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51289 {
51290 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51291 }
51292 {
51293 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51294 }
51295 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51296 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51297 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51298 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51299 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51300 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51301 {
51302 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51303 }
51304 {
51305 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51306 }
51307 {
51308 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51309 }
51310 {
51311 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51312 }
51313 {
51314 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51315 }
51316 {
51317 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51318 }
51319 {
51320 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51321 }
51322 {
51323 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51324 }
51325 {
51326 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51327 }
51328 {
51329 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51330 }
51331 {
51332 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51333 }
51334 {
51335 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51336 }
51337 {
51338 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51339 }
51340 {
51341 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51342 }
51343 {
51344 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51345 }
51346 {
51347 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51348 }
51349 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51350 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51351 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51352 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51353 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51354 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51355 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51356 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51357 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51358 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51359 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51360 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51361 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51362 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51363 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51364 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51365 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51366 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51367 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51368 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51369 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51370 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51371 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51372 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51373 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51374 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51375 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51376 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51377 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51378 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51379 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51380 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51381 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51382 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51383 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51384 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51385 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51386 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51387 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51388 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51389 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51390 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51391 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51392 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51393 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51394 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51395 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51396 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51397 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51398 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51399 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51400 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51401 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51402 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51403 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51404 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51405 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51406 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51407 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51408 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51409 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51410 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51411 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51412 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51413 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51414 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51415 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51416 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51417 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51418 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51419 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51420 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51421 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51422 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51423 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51424 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51425 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51426 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51427 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51428 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51429 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51430 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51431 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51432 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51433 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51434 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51435 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51436 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51437 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51438 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51439 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51440 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51441 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51442 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51443 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51444 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51445 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51446 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51447 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51448 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51449 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51450 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51451 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51452 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51453 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51454 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51455 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51456 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51457 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51458 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51459 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51460 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51461 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51462 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51463 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51464 {
51465 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51466 }
51467 {
51468 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51469 }
51470 {
51471 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51472 }
51473 {
51474 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51475 }
51476 {
51477 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51478 }
51479 {
51480 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51481 }
51482 {
51483 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51484 }
51485 {
51486 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51487 }
51488 {
51489 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51490 }
51491 {
51492 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51493 }
51494 {
51495 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51496 }
51497 {
51498 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51499 }
51500 {
51501 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51502 }
51503 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51504 {
51505 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51506 }
51507 {
51508 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51509 }
51510 {
51511 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51512 }
51513 {
51514 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51515 }
51516 {
51517 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51518 }
51519 {
51520 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51521 }
51522 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51523 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51524 {
51525 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51526 }
51527 {
51528 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51529 }
51530 {
51531 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51532 }
51533 {
51534 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51535 }
51536 {
51537 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51538 }
51539 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51540 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51541 {
51542 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51543 }
51544 {
51545 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51546 }
51547 {
51548 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51549 }
51550 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51551 {
51552 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51553 }
51554 {
51555 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51556 }
51557 {
51558 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51559 }
51560 {
51561 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51562 }
51563 {
51564 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51565 }
51566 {
51567 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51568 }
51569 {
51570 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51571 }
51572 {
51573 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51574 }
51575 {
51576 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51577 }
51578 {
51579 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51580 }
51581 {
51582 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51583 }
51584 {
51585 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51586 }
51587 {
51588 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51589 }
51590 {
51591 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51592 }
51593 {
51594 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51595 }
51596 {
51597 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51598 }
51599 {
51600 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51601 }
51602 {
51603 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51604 }
51605 {
51606 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51607 }
51608
51609 // Initialize threading, some globals and such
51610 __wxPyPreStart(d);
51611
51612
51613 // Although these are defined in __version__ they need to be here too so
51614 // that an assert can be done to ensure that the wxPython and the wxWindows
51615 // versions match.
51616 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51617 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51618 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51619
51620 }
51621
wxWidgets (Impactor)