]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


fdc489951261fb1949e521e742c9b52758d18f18
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_VERSION 0x010327
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /***********************************************************************
31 *
32 * This section contains generic SWIG labels for method/variable
33 * declarations/attributes, and other compiler dependent labels.
34 *
35 ************************************************************************/
36
37 /* template workaround for compilers that cannot correctly implement the C++ standard */
38 #ifndef SWIGTEMPLATEDISAMBIGUATOR
39 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
40 # define SWIGTEMPLATEDISAMBIGUATOR template
41 # else
42 # define SWIGTEMPLATEDISAMBIGUATOR
43 # endif
44 #endif
45
46 /* inline attribute */
47 #ifndef SWIGINLINE
48 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
49 # define SWIGINLINE inline
50 # else
51 # define SWIGINLINE
52 # endif
53 #endif
54
55 /* attribute recognised by some compilers to avoid 'unused' warnings */
56 #ifndef SWIGUNUSED
57 # if defined(__GNUC__) || defined(__ICC)
58 # define SWIGUNUSED __attribute__ ((unused))
59 # else
60 # define SWIGUNUSED
61 # endif
62 #endif
63
64 /* internal SWIG method */
65 #ifndef SWIGINTERN
66 # define SWIGINTERN static SWIGUNUSED
67 #endif
68
69 /* internal inline SWIG method */
70 #ifndef SWIGINTERNINLINE
71 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
72 #endif
73
74 /* exporting methods for Windows DLLs */
75 #ifndef SWIGEXPORT
76 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
77 # if defined(STATIC_LINKED)
78 # define SWIGEXPORT
79 # else
80 # define SWIGEXPORT __declspec(dllexport)
81 # endif
82 # else
83 # define SWIGEXPORT
84 # endif
85 #endif
86
87 /* calling conventions for Windows */
88 #ifndef SWIGSTDCALL
89 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
90 # define SWIGSTDCALL __stdcall
91 # else
92 # define SWIGSTDCALL
93 # endif
94 #endif
95
96
97
98 #include <Python.h>
99
100 /***********************************************************************
101 * swigrun.swg
102 *
103 * This file contains generic CAPI SWIG runtime support for pointer
104 * type checking.
105 *
106 ************************************************************************/
107
108 /* This should only be incremented when either the layout of swig_type_info changes,
109 or for whatever reason, the runtime changes incompatibly */
110 #define SWIG_RUNTIME_VERSION "2"
111
112 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
113 #ifdef SWIG_TYPE_TABLE
114 # define SWIG_QUOTE_STRING(x) #x
115 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
116 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
117 #else
118 # define SWIG_TYPE_TABLE_NAME
119 #endif
120
121 /*
122 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
123 creating a static or dynamic library from the swig runtime code.
124 In 99.9% of the cases, swig just needs to declare them as 'static'.
125
126 But only do this if is strictly necessary, ie, if you have problems
127 with your compiler or so.
128 */
129
130 #ifndef SWIGRUNTIME
131 # define SWIGRUNTIME SWIGINTERN
132 #endif
133
134 #ifndef SWIGRUNTIMEINLINE
135 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
136 #endif
137
138 #include <string.h>
139
140 #ifdef __cplusplus
141 extern "C" {
142 #endif
143
144 typedef void *(*swig_converter_func)(void *);
145 typedef struct swig_type_info *(*swig_dycast_func)(void **);
146
147 /* Structure to store inforomation on one type */
148 typedef struct swig_type_info {
149 const char *name; /* mangled name of this type */
150 const char *str; /* human readable name of this type */
151 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
152 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
153 void *clientdata; /* language specific type data */
154 } swig_type_info;
155
156 /* Structure to store a type and conversion function used for casting */
157 typedef struct swig_cast_info {
158 swig_type_info *type; /* pointer to type that is equivalent to this type */
159 swig_converter_func converter; /* function to cast the void pointers */
160 struct swig_cast_info *next; /* pointer to next cast in linked list */
161 struct swig_cast_info *prev; /* pointer to the previous cast */
162 } swig_cast_info;
163
164 /* Structure used to store module information
165 * Each module generates one structure like this, and the runtime collects
166 * all of these structures and stores them in a circularly linked list.*/
167 typedef struct swig_module_info {
168 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
169 size_t size; /* Number of types in this module */
170 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
171 swig_type_info **type_initial; /* Array of initially generated type structures */
172 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
173 void *clientdata; /* Language specific module data */
174 } swig_module_info;
175
176
177 /*
178 Compare two type names skipping the space characters, therefore
179 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
180
181 Return 0 when the two name types are equivalent, as in
182 strncmp, but skipping ' '.
183 */
184 SWIGRUNTIME int
185 SWIG_TypeNameComp(const char *f1, const char *l1,
186 const char *f2, const char *l2) {
187 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
188 while ((*f1 == ' ') && (f1 != l1)) ++f1;
189 while ((*f2 == ' ') && (f2 != l2)) ++f2;
190 if (*f1 != *f2) return (int)(*f1 - *f2);
191 }
192 return (l1 - f1) - (l2 - f2);
193 }
194
195 /*
196 Check type equivalence in a name list like <name1>|<name2>|...
197 Return 0 if not equal, 1 if equal
198 */
199 SWIGRUNTIME int
200 SWIG_TypeEquiv(const char *nb, const char *tb) {
201 int equiv = 0;
202 const char* te = tb + strlen(tb);
203 const char* ne = nb;
204 while (!equiv && *ne) {
205 for (nb = ne; *ne; ++ne) {
206 if (*ne == '|') break;
207 }
208 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
209 if (*ne) ++ne;
210 }
211 return equiv;
212 }
213
214 /*
215 Check type equivalence in a name list like <name1>|<name2>|...
216 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
217 */
218 SWIGRUNTIME int
219 SWIG_TypeCompare(const char *nb, const char *tb) {
220 int equiv = 0;
221 const char* te = tb + strlen(tb);
222 const char* ne = nb;
223 while (!equiv && *ne) {
224 for (nb = ne; *ne; ++ne) {
225 if (*ne == '|') break;
226 }
227 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
228 if (*ne) ++ne;
229 }
230 return equiv;
231 }
232
233
234 /* think of this as a c++ template<> or a scheme macro */
235 #define SWIG_TypeCheck_Template(comparison, ty) \
236 if (ty) { \
237 swig_cast_info *iter = ty->cast; \
238 while (iter) { \
239 if (comparison) { \
240 if (iter == ty->cast) return iter; \
241 /* Move iter to the top of the linked list */ \
242 iter->prev->next = iter->next; \
243 if (iter->next) \
244 iter->next->prev = iter->prev; \
245 iter->next = ty->cast; \
246 iter->prev = 0; \
247 if (ty->cast) ty->cast->prev = iter; \
248 ty->cast = iter; \
249 return iter; \
250 } \
251 iter = iter->next; \
252 } \
253 } \
254 return 0
255
256 /*
257 Check the typename
258 */
259 SWIGRUNTIME swig_cast_info *
260 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
261 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
262 }
263
264 /* Same as previous function, except strcmp is replaced with a pointer comparison */
265 SWIGRUNTIME swig_cast_info *
266 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
267 SWIG_TypeCheck_Template(iter->type == from, into);
268 }
269
270 /*
271 Cast a pointer up an inheritance hierarchy
272 */
273 SWIGRUNTIMEINLINE void *
274 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
275 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
276 }
277
278 /*
279 Dynamic pointer casting. Down an inheritance hierarchy
280 */
281 SWIGRUNTIME swig_type_info *
282 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
283 swig_type_info *lastty = ty;
284 if (!ty || !ty->dcast) return ty;
285 while (ty && (ty->dcast)) {
286 ty = (*ty->dcast)(ptr);
287 if (ty) lastty = ty;
288 }
289 return lastty;
290 }
291
292 /*
293 Return the name associated with this type
294 */
295 SWIGRUNTIMEINLINE const char *
296 SWIG_TypeName(const swig_type_info *ty) {
297 return ty->name;
298 }
299
300 /*
301 Return the pretty name associated with this type,
302 that is an unmangled type name in a form presentable to the user.
303 */
304 SWIGRUNTIME const char *
305 SWIG_TypePrettyName(const swig_type_info *type) {
306 /* The "str" field contains the equivalent pretty names of the
307 type, separated by vertical-bar characters. We choose
308 to print the last name, as it is often (?) the most
309 specific. */
310 if (type->str != NULL) {
311 const char *last_name = type->str;
312 const char *s;
313 for (s = type->str; *s; s++)
314 if (*s == '|') last_name = s+1;
315 return last_name;
316 }
317 else
318 return type->name;
319 }
320
321 /*
322 Set the clientdata field for a type
323 */
324 SWIGRUNTIME void
325 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
326 swig_cast_info *cast = ti->cast;
327 /* if (ti->clientdata == clientdata) return; */
328 ti->clientdata = clientdata;
329
330 while (cast) {
331 if (!cast->converter) {
332 swig_type_info *tc = cast->type;
333 if (!tc->clientdata) {
334 SWIG_TypeClientData(tc, clientdata);
335 }
336 }
337 cast = cast->next;
338 }
339 }
340
341 /*
342 Search for a swig_type_info structure only by mangled name
343 Search is a O(log #types)
344
345 We start searching at module start, and finish searching when start == end.
346 Note: if start == end at the beginning of the function, we go all the way around
347 the circular list.
348 */
349 SWIGRUNTIME swig_type_info *
350 SWIG_MangledTypeQueryModule(swig_module_info *start,
351 swig_module_info *end,
352 const char *name) {
353 swig_module_info *iter = start;
354 do {
355 if (iter->size) {
356 register size_t l = 0;
357 register size_t r = iter->size - 1;
358 do {
359 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
360 register size_t i = (l + r) >> 1;
361 const char *iname = iter->types[i]->name;
362 if (iname) {
363 register int compare = strcmp(name, iname);
364 if (compare == 0) {
365 return iter->types[i];
366 } else if (compare < 0) {
367 if (i) {
368 r = i - 1;
369 } else {
370 break;
371 }
372 } else if (compare > 0) {
373 l = i + 1;
374 }
375 } else {
376 break; /* should never happen */
377 }
378 } while (l <= r);
379 }
380 iter = iter->next;
381 } while (iter != end);
382 return 0;
383 }
384
385 /*
386 Search for a swig_type_info structure for either a mangled name or a human readable name.
387 It first searches the mangled names of the types, which is a O(log #types)
388 If a type is not found it then searches the human readable names, which is O(#types).
389
390 We start searching at module start, and finish searching when start == end.
391 Note: if start == end at the beginning of the function, we go all the way around
392 the circular list.
393 */
394 SWIGRUNTIME swig_type_info *
395 SWIG_TypeQueryModule(swig_module_info *start,
396 swig_module_info *end,
397 const char *name) {
398 /* STEP 1: Search the name field using binary search */
399 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
400 if (ret) {
401 return ret;
402 } else {
403 /* STEP 2: If the type hasn't been found, do a complete search
404 of the str field (the human readable name) */
405 swig_module_info *iter = start;
406 do {
407 register size_t i = 0;
408 for (; i < iter->size; ++i) {
409 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
410 return iter->types[i];
411 }
412 iter = iter->next;
413 } while (iter != end);
414 }
415
416 /* neither found a match */
417 return 0;
418 }
419
420
421 /*
422 Pack binary data into a string
423 */
424 SWIGRUNTIME char *
425 SWIG_PackData(char *c, void *ptr, size_t sz) {
426 static const char hex[17] = "0123456789abcdef";
427 register const unsigned char *u = (unsigned char *) ptr;
428 register const unsigned char *eu = u + sz;
429 for (; u != eu; ++u) {
430 register unsigned char uu = *u;
431 *(c++) = hex[(uu & 0xf0) >> 4];
432 *(c++) = hex[uu & 0xf];
433 }
434 return c;
435 }
436
437 /*
438 Unpack binary data from a string
439 */
440 SWIGRUNTIME const char *
441 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
442 register unsigned char *u = (unsigned char *) ptr;
443 register const unsigned char *eu = u + sz;
444 for (; u != eu; ++u) {
445 register char d = *(c++);
446 register unsigned char uu = 0;
447 if ((d >= '0') && (d <= '9'))
448 uu = ((d - '0') << 4);
449 else if ((d >= 'a') && (d <= 'f'))
450 uu = ((d - ('a'-10)) << 4);
451 else
452 return (char *) 0;
453 d = *(c++);
454 if ((d >= '0') && (d <= '9'))
455 uu |= (d - '0');
456 else if ((d >= 'a') && (d <= 'f'))
457 uu |= (d - ('a'-10));
458 else
459 return (char *) 0;
460 *u = uu;
461 }
462 return c;
463 }
464
465 /*
466 Pack 'void *' into a string buffer.
467 */
468 SWIGRUNTIME char *
469 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
470 char *r = buff;
471 if ((2*sizeof(void *) + 2) > bsz) return 0;
472 *(r++) = '_';
473 r = SWIG_PackData(r,&ptr,sizeof(void *));
474 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
475 strcpy(r,name);
476 return buff;
477 }
478
479 SWIGRUNTIME const char *
480 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
481 if (*c != '_') {
482 if (strcmp(c,"NULL") == 0) {
483 *ptr = (void *) 0;
484 return name;
485 } else {
486 return 0;
487 }
488 }
489 return SWIG_UnpackData(++c,ptr,sizeof(void *));
490 }
491
492 SWIGRUNTIME char *
493 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
494 char *r = buff;
495 size_t lname = (name ? strlen(name) : 0);
496 if ((2*sz + 2 + lname) > bsz) return 0;
497 *(r++) = '_';
498 r = SWIG_PackData(r,ptr,sz);
499 if (lname) {
500 strncpy(r,name,lname+1);
501 } else {
502 *r = 0;
503 }
504 return buff;
505 }
506
507 SWIGRUNTIME const char *
508 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
509 if (*c != '_') {
510 if (strcmp(c,"NULL") == 0) {
511 memset(ptr,0,sz);
512 return name;
513 } else {
514 return 0;
515 }
516 }
517 return SWIG_UnpackData(++c,ptr,sz);
518 }
519
520 #ifdef __cplusplus
521 }
522 #endif
523
524 /* -----------------------------------------------------------------------------
525 * SWIG API. Portion that goes into the runtime
526 * ----------------------------------------------------------------------------- */
527
528 #ifdef __cplusplus
529 extern "C" {
530 #endif
531
532 /* -----------------------------------------------------------------------------
533 * for internal method declarations
534 * ----------------------------------------------------------------------------- */
535
536 #ifndef SWIGINTERN
537 # define SWIGINTERN static SWIGUNUSED
538 #endif
539
540 #ifndef SWIGINTERNINLINE
541 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
542 #endif
543
544 /*
545 Exception handling in wrappers
546 */
547 #define SWIG_fail goto fail
548 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
549 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
550 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
551 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
552 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
553
554 /*
555 Contract support
556 */
557 #define SWIG_contract_assert(expr, msg) \
558 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
559
560 /* -----------------------------------------------------------------------------
561 * Constant declarations
562 * ----------------------------------------------------------------------------- */
563
564 /* Constant Types */
565 #define SWIG_PY_INT 1
566 #define SWIG_PY_FLOAT 2
567 #define SWIG_PY_STRING 3
568 #define SWIG_PY_POINTER 4
569 #define SWIG_PY_BINARY 5
570
571 /* Constant information structure */
572 typedef struct swig_const_info {
573 int type;
574 char *name;
575 long lvalue;
576 double dvalue;
577 void *pvalue;
578 swig_type_info **ptype;
579 } swig_const_info;
580
581
582 /* -----------------------------------------------------------------------------
583 * Alloc. memory flags
584 * ----------------------------------------------------------------------------- */
585 #define SWIG_OLDOBJ 1
586 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
587 #define SWIG_PYSTR SWIG_NEWOBJ + 1
588
589 #ifdef __cplusplus
590 }
591 #endif
592
593
594 /***********************************************************************
595 * pyrun.swg
596 *
597 * This file contains the runtime support for Python modules
598 * and includes code for managing global variables and pointer
599 * type checking.
600 *
601 * Author : David Beazley (beazley@cs.uchicago.edu)
602 ************************************************************************/
603
604 /* Common SWIG API */
605 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
606 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
607 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
608
609
610 /* Python-specific SWIG API */
611 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
612 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
613
614 /* Runtime API */
615 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
616 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
617
618 /* -----------------------------------------------------------------------------
619 * Pointer declarations
620 * ----------------------------------------------------------------------------- */
621 /*
622 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
623 C/C++ pointers in the python side. Very useful for debugging, but
624 not always safe.
625 */
626 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
627 # define SWIG_COBJECT_TYPES
628 #endif
629
630 /* Flags for pointer conversion */
631 #define SWIG_POINTER_EXCEPTION 0x1
632 #define SWIG_POINTER_DISOWN 0x2
633
634
635 /* Add PyOS_snprintf for old Pythons */
636 #if PY_VERSION_HEX < 0x02020000
637 #define PyOS_snprintf snprintf
638 #endif
639
640 #ifdef __cplusplus
641 extern "C" {
642 #endif
643
644 /* -----------------------------------------------------------------------------
645 * Create a new pointer string
646 * ----------------------------------------------------------------------------- */
647 #ifndef SWIG_BUFFER_SIZE
648 #define SWIG_BUFFER_SIZE 1024
649 #endif
650
651 /* A crude PyString_FromFormat implementation for old Pythons */
652 #if PY_VERSION_HEX < 0x02020000
653 static PyObject *
654 PyString_FromFormat(const char *fmt, ...) {
655 va_list ap;
656 char buf[SWIG_BUFFER_SIZE * 2];
657 int res;
658 va_start(ap, fmt);
659 res = vsnprintf(buf, sizeof(buf), fmt, ap);
660 va_end(ap);
661 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
662 }
663 #endif
664
665 #if PY_VERSION_HEX < 0x01060000
666 #define PyObject_Del(op) PyMem_DEL((op))
667 #endif
668
669 #if defined(SWIG_COBJECT_TYPES)
670 #if !defined(SWIG_COBJECT_PYTHON)
671 /* -----------------------------------------------------------------------------
672 * Implements a simple Swig Object type, and use it instead of PyCObject
673 * ----------------------------------------------------------------------------- */
674
675 typedef struct {
676 PyObject_HEAD
677 void *ptr;
678 const char *desc;
679 } PySwigObject;
680
681 /* Declarations for objects of type PySwigObject */
682
683 SWIGRUNTIME int
684 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
685 {
686 char result[SWIG_BUFFER_SIZE];
687 flags = flags;
688 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
689 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
690 return 0;
691 } else {
692 return 1;
693 }
694 }
695
696 SWIGRUNTIME PyObject *
697 PySwigObject_repr(PySwigObject *v)
698 {
699 char result[SWIG_BUFFER_SIZE];
700 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
701 PyString_FromFormat("<Swig Object at %s>", result) : 0;
702 }
703
704 SWIGRUNTIME PyObject *
705 PySwigObject_str(PySwigObject *v)
706 {
707 char result[SWIG_BUFFER_SIZE];
708 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
709 PyString_FromString(result) : 0;
710 }
711
712 SWIGRUNTIME PyObject *
713 PySwigObject_long(PySwigObject *v)
714 {
715 return PyLong_FromVoidPtr(v->ptr);
716 }
717
718 SWIGRUNTIME PyObject *
719 PySwigObject_format(const char* fmt, PySwigObject *v)
720 {
721 PyObject *res = NULL;
722 PyObject *args = PyTuple_New(1);
723 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
724 PyObject *ofmt = PyString_FromString(fmt);
725 if (ofmt) {
726 res = PyString_Format(ofmt,args);
727 Py_DECREF(ofmt);
728 }
729 Py_DECREF(args);
730 }
731 return res;
732 }
733
734 SWIGRUNTIME PyObject *
735 PySwigObject_oct(PySwigObject *v)
736 {
737 return PySwigObject_format("%o",v);
738 }
739
740 SWIGRUNTIME PyObject *
741 PySwigObject_hex(PySwigObject *v)
742 {
743 return PySwigObject_format("%x",v);
744 }
745
746 SWIGRUNTIME int
747 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
748 {
749 int c = strcmp(v->desc, w->desc);
750 if (c) {
751 return (c > 0) ? 1 : -1;
752 } else {
753 void *i = v->ptr;
754 void *j = w->ptr;
755 return (i < j) ? -1 : ((i > j) ? 1 : 0);
756 }
757 }
758
759 SWIGRUNTIME void
760 PySwigObject_dealloc(PySwigObject *self)
761 {
762 PyObject_Del(self);
763 }
764
765 SWIGRUNTIME PyTypeObject*
766 PySwigObject_type(void) {
767 static char pyswigobject_type__doc__[] =
768 "Swig object carries a C/C++ instance pointer";
769
770 static PyNumberMethods PySwigObject_as_number = {
771 (binaryfunc)0, /*nb_add*/
772 (binaryfunc)0, /*nb_subtract*/
773 (binaryfunc)0, /*nb_multiply*/
774 (binaryfunc)0, /*nb_divide*/
775 (binaryfunc)0, /*nb_remainder*/
776 (binaryfunc)0, /*nb_divmod*/
777 (ternaryfunc)0,/*nb_power*/
778 (unaryfunc)0, /*nb_negative*/
779 (unaryfunc)0, /*nb_positive*/
780 (unaryfunc)0, /*nb_absolute*/
781 (inquiry)0, /*nb_nonzero*/
782 0, /*nb_invert*/
783 0, /*nb_lshift*/
784 0, /*nb_rshift*/
785 0, /*nb_and*/
786 0, /*nb_xor*/
787 0, /*nb_or*/
788 (coercion)0, /*nb_coerce*/
789 (unaryfunc)PySwigObject_long, /*nb_int*/
790 (unaryfunc)PySwigObject_long, /*nb_long*/
791 (unaryfunc)0, /*nb_float*/
792 (unaryfunc)PySwigObject_oct, /*nb_oct*/
793 (unaryfunc)PySwigObject_hex, /*nb_hex*/
794 #if PY_VERSION_HEX >= 0x02020000
795 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
796 #elif PY_VERSION_HEX >= 0x02000000
797 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
798 #endif
799 };
800
801 static PyTypeObject pyswigobject_type
802 #if !defined(__cplusplus)
803 ;
804 static int type_init = 0;
805 if (!type_init) {
806 PyTypeObject tmp
807 #endif
808 = {
809 PyObject_HEAD_INIT(&PyType_Type)
810 0, /*ob_size*/
811 (char *)"PySwigObject", /*tp_name*/
812 sizeof(PySwigObject), /*tp_basicsize*/
813 0, /*tp_itemsize*/
814 /* methods */
815 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
816 (printfunc)PySwigObject_print, /*tp_print*/
817 (getattrfunc)0, /*tp_getattr*/
818 (setattrfunc)0, /*tp_setattr*/
819 (cmpfunc)PySwigObject_compare, /*tp_compare*/
820 (reprfunc)PySwigObject_repr, /*tp_repr*/
821 &PySwigObject_as_number, /*tp_as_number*/
822 0, /*tp_as_sequence*/
823 0, /*tp_as_mapping*/
824 (hashfunc)0, /*tp_hash*/
825 (ternaryfunc)0, /*tp_call*/
826 (reprfunc)PySwigObject_str, /*tp_str*/
827 /* Space for future expansion */
828 0,0,0,0,
829 pyswigobject_type__doc__, /* Documentation string */
830 #if PY_VERSION_HEX >= 0x02000000
831 0, /* tp_traverse */
832 0, /* tp_clear */
833 #endif
834 #if PY_VERSION_HEX >= 0x02010000
835 0, /* tp_richcompare */
836 0, /* tp_weaklistoffset */
837 #endif
838 #if PY_VERSION_HEX >= 0x02020000
839 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
840 #endif
841 #if PY_VERSION_HEX >= 0x02030000
842 0, /* tp_del */
843 #endif
844 #ifdef COUNT_ALLOCS
845 0,0,0,0 /* tp_alloc -> tp_next */
846 #endif
847 };
848 #if !defined(__cplusplus)
849 pyswigobject_type = tmp;
850 type_init = 1;
851 }
852 #endif
853 return &pyswigobject_type;
854 }
855
856 SWIGRUNTIME PyObject *
857 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
858 {
859 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
860 if (self) {
861 self->ptr = ptr;
862 self->desc = desc;
863 }
864 return (PyObject *)self;
865 }
866
867 SWIGRUNTIMEINLINE void *
868 PySwigObject_AsVoidPtr(PyObject *self)
869 {
870 return ((PySwigObject *)self)->ptr;
871 }
872
873 SWIGRUNTIMEINLINE const char *
874 PySwigObject_GetDesc(PyObject *self)
875 {
876 return ((PySwigObject *)self)->desc;
877 }
878
879 SWIGRUNTIMEINLINE int
880 PySwigObject_Check(PyObject *op) {
881 return ((op)->ob_type == PySwigObject_type())
882 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
883 }
884
885 /* -----------------------------------------------------------------------------
886 * Implements a simple Swig Packed type, and use it instead of string
887 * ----------------------------------------------------------------------------- */
888
889 typedef struct {
890 PyObject_HEAD
891 void *pack;
892 const char *desc;
893 size_t size;
894 } PySwigPacked;
895
896 SWIGRUNTIME int
897 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
898 {
899 char result[SWIG_BUFFER_SIZE];
900 flags = flags;
901 fputs("<Swig Packed ", fp);
902 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
903 fputs("at ", fp);
904 fputs(result, fp);
905 }
906 fputs(v->desc,fp);
907 fputs(">", fp);
908 return 0;
909 }
910
911 SWIGRUNTIME PyObject *
912 PySwigPacked_repr(PySwigPacked *v)
913 {
914 char result[SWIG_BUFFER_SIZE];
915 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
916 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
917 } else {
918 return PyString_FromFormat("<Swig Packed %s>", v->desc);
919 }
920 }
921
922 SWIGRUNTIME PyObject *
923 PySwigPacked_str(PySwigPacked *v)
924 {
925 char result[SWIG_BUFFER_SIZE];
926 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
927 return PyString_FromFormat("%s%s", result, v->desc);
928 } else {
929 return PyString_FromString(v->desc);
930 }
931 }
932
933 SWIGRUNTIME int
934 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
935 {
936 int c = strcmp(v->desc, w->desc);
937 if (c) {
938 return (c > 0) ? 1 : -1;
939 } else {
940 size_t i = v->size;
941 size_t j = w->size;
942 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
943 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
944 }
945 }
946
947 SWIGRUNTIME void
948 PySwigPacked_dealloc(PySwigPacked *self)
949 {
950 free(self->pack);
951 PyObject_Del(self);
952 }
953
954 SWIGRUNTIME PyTypeObject*
955 PySwigPacked_type(void) {
956 static char pyswigpacked_type__doc__[] =
957 "Swig object carries a C/C++ instance pointer";
958 static PyTypeObject pyswigpacked_type
959 #if !defined(__cplusplus)
960 ;
961 static int type_init = 0;
962 if (!type_init) {
963 PyTypeObject tmp
964 #endif
965 = {
966 PyObject_HEAD_INIT(&PyType_Type)
967 0, /*ob_size*/
968 (char *)"PySwigPacked", /*tp_name*/
969 sizeof(PySwigPacked), /*tp_basicsize*/
970 0, /*tp_itemsize*/
971 /* methods */
972 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
973 (printfunc)PySwigPacked_print, /*tp_print*/
974 (getattrfunc)0, /*tp_getattr*/
975 (setattrfunc)0, /*tp_setattr*/
976 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
977 (reprfunc)PySwigPacked_repr, /*tp_repr*/
978 0, /*tp_as_number*/
979 0, /*tp_as_sequence*/
980 0, /*tp_as_mapping*/
981 (hashfunc)0, /*tp_hash*/
982 (ternaryfunc)0, /*tp_call*/
983 (reprfunc)PySwigPacked_str, /*tp_str*/
984 /* Space for future expansion */
985 0,0,0,0,
986 pyswigpacked_type__doc__, /* Documentation string */
987 #if PY_VERSION_HEX >= 0x02000000
988 0, /* tp_traverse */
989 0, /* tp_clear */
990 #endif
991 #if PY_VERSION_HEX >= 0x02010000
992 0, /* tp_richcompare */
993 0, /* tp_weaklistoffset */
994 #endif
995 #if PY_VERSION_HEX >= 0x02020000
996 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
997 #endif
998 #if PY_VERSION_HEX >= 0x02030000
999 0, /* tp_del */
1000 #endif
1001 #ifdef COUNT_ALLOCS
1002 0,0,0,0 /* tp_alloc -> tp_next */
1003 #endif
1004 };
1005 #if !defined(__cplusplus)
1006 pyswigpacked_type = tmp;
1007 type_init = 1;
1008 }
1009 #endif
1010 return &pyswigpacked_type;
1011 }
1012
1013 SWIGRUNTIME PyObject *
1014 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1015 {
1016 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1017 if (self == NULL) {
1018 return NULL;
1019 } else {
1020 void *pack = malloc(size);
1021 if (pack) {
1022 memcpy(pack, ptr, size);
1023 self->pack = pack;
1024 self->desc = desc;
1025 self->size = size;
1026 return (PyObject *) self;
1027 }
1028 return NULL;
1029 }
1030 }
1031
1032 SWIGRUNTIMEINLINE const char *
1033 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1034 {
1035 PySwigPacked *self = (PySwigPacked *)obj;
1036 if (self->size != size) return 0;
1037 memcpy(ptr, self->pack, size);
1038 return self->desc;
1039 }
1040
1041 SWIGRUNTIMEINLINE const char *
1042 PySwigPacked_GetDesc(PyObject *self)
1043 {
1044 return ((PySwigPacked *)self)->desc;
1045 }
1046
1047 SWIGRUNTIMEINLINE int
1048 PySwigPacked_Check(PyObject *op) {
1049 return ((op)->ob_type == PySwigPacked_type())
1050 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1051 }
1052
1053 #else
1054 /* -----------------------------------------------------------------------------
1055 * Use the old Python PyCObject instead of PySwigObject
1056 * ----------------------------------------------------------------------------- */
1057
1058 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1059 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1060 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1061 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1062
1063 #endif
1064
1065 #endif
1066
1067 /* -----------------------------------------------------------------------------
1068 * errors manipulation
1069 * ----------------------------------------------------------------------------- */
1070
1071 SWIGRUNTIME void
1072 SWIG_Python_TypeError(const char *type, PyObject *obj)
1073 {
1074 if (type) {
1075 #if defined(SWIG_COBJECT_TYPES)
1076 if (obj && PySwigObject_Check(obj)) {
1077 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1078 if (otype) {
1079 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1080 type, otype);
1081 return;
1082 }
1083 } else
1084 #endif
1085 {
1086 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1087 if (otype) {
1088 PyObject *str = PyObject_Str(obj);
1089 const char *cstr = str ? PyString_AsString(str) : 0;
1090 if (cstr) {
1091 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1092 type, otype, cstr);
1093 } else {
1094 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1095 type, otype);
1096 }
1097 Py_XDECREF(str);
1098 return;
1099 }
1100 }
1101 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1102 } else {
1103 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1104 }
1105 }
1106
1107 SWIGRUNTIMEINLINE void
1108 SWIG_Python_NullRef(const char *type)
1109 {
1110 if (type) {
1111 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1112 } else {
1113 PyErr_Format(PyExc_TypeError, "null reference was received");
1114 }
1115 }
1116
1117 SWIGRUNTIME int
1118 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1119 {
1120 if (PyErr_Occurred()) {
1121 PyObject *type = 0;
1122 PyObject *value = 0;
1123 PyObject *traceback = 0;
1124 PyErr_Fetch(&type, &value, &traceback);
1125 if (value) {
1126 PyObject *old_str = PyObject_Str(value);
1127 Py_XINCREF(type);
1128 PyErr_Clear();
1129 if (infront) {
1130 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1131 } else {
1132 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1133 }
1134 Py_DECREF(old_str);
1135 }
1136 return 1;
1137 } else {
1138 return 0;
1139 }
1140 }
1141
1142 SWIGRUNTIME int
1143 SWIG_Python_ArgFail(int argnum)
1144 {
1145 if (PyErr_Occurred()) {
1146 /* add information about failing argument */
1147 char mesg[256];
1148 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1149 return SWIG_Python_AddErrMesg(mesg, 1);
1150 } else {
1151 return 0;
1152 }
1153 }
1154
1155
1156 /* -----------------------------------------------------------------------------
1157 * pointers/data manipulation
1158 * ----------------------------------------------------------------------------- */
1159
1160 /* Convert a pointer value */
1161 SWIGRUNTIME int
1162 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1163 swig_cast_info *tc;
1164 const char *c = 0;
1165 static PyObject *SWIG_this = 0;
1166 int newref = 0;
1167 PyObject *pyobj = 0;
1168 void *vptr;
1169
1170 if (!obj) return 0;
1171 if (obj == Py_None) {
1172 *ptr = 0;
1173 return 0;
1174 }
1175
1176 #ifdef SWIG_COBJECT_TYPES
1177 if (!(PySwigObject_Check(obj))) {
1178 if (!SWIG_this)
1179 SWIG_this = PyString_FromString("this");
1180 pyobj = obj;
1181 obj = PyObject_GetAttr(obj,SWIG_this);
1182 newref = 1;
1183 if (!obj) goto type_error;
1184 if (!PySwigObject_Check(obj)) {
1185 Py_DECREF(obj);
1186 goto type_error;
1187 }
1188 }
1189 vptr = PySwigObject_AsVoidPtr(obj);
1190 c = (const char *) PySwigObject_GetDesc(obj);
1191 if (newref) { Py_DECREF(obj); }
1192 goto type_check;
1193 #else
1194 if (!(PyString_Check(obj))) {
1195 if (!SWIG_this)
1196 SWIG_this = PyString_FromString("this");
1197 pyobj = obj;
1198 obj = PyObject_GetAttr(obj,SWIG_this);
1199 newref = 1;
1200 if (!obj) goto type_error;
1201 if (!PyString_Check(obj)) {
1202 Py_DECREF(obj);
1203 goto type_error;
1204 }
1205 }
1206 c = PyString_AsString(obj);
1207 /* Pointer values must start with leading underscore */
1208 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1209 if (newref) { Py_DECREF(obj); }
1210 if (!c) goto type_error;
1211 #endif
1212
1213 type_check:
1214 if (ty) {
1215 tc = SWIG_TypeCheck(c,ty);
1216 if (!tc) goto type_error;
1217 *ptr = SWIG_TypeCast(tc,vptr);
1218 } else {
1219 *ptr = vptr;
1220 }
1221 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1222 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1223 }
1224 return 0;
1225
1226 type_error:
1227 PyErr_Clear();
1228 if (pyobj && !obj) {
1229 obj = pyobj;
1230 if (PyCFunction_Check(obj)) {
1231 /* here we get the method pointer for callbacks */
1232 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1233 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1234 if (c) {
1235 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1236 if (!c) goto type_error;
1237 goto type_check;
1238 }
1239 }
1240 }
1241 if (flags & SWIG_POINTER_EXCEPTION) {
1242 if (ty) {
1243 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1244 } else {
1245 SWIG_Python_TypeError("C/C++ pointer", obj);
1246 }
1247 }
1248 return -1;
1249 }
1250
1251 /* Convert a pointer value, signal an exception on a type mismatch */
1252 SWIGRUNTIME void *
1253 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1254 void *result;
1255 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1256 PyErr_Clear();
1257 if (flags & SWIG_POINTER_EXCEPTION) {
1258 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1259 SWIG_Python_ArgFail(argnum);
1260 }
1261 }
1262 return result;
1263 }
1264
1265 /* Convert a packed value value */
1266 SWIGRUNTIME int
1267 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1268 swig_cast_info *tc;
1269 const char *c = 0;
1270
1271 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1272 c = PySwigPacked_UnpackData(obj, ptr, sz);
1273 #else
1274 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1275 c = PyString_AsString(obj);
1276 /* Pointer values must start with leading underscore */
1277 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1278 #endif
1279 if (!c) goto type_error;
1280 if (ty) {
1281 tc = SWIG_TypeCheck(c,ty);
1282 if (!tc) goto type_error;
1283 }
1284 return 0;
1285
1286 type_error:
1287 PyErr_Clear();
1288 if (flags & SWIG_POINTER_EXCEPTION) {
1289 if (ty) {
1290 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1291 } else {
1292 SWIG_Python_TypeError("C/C++ packed data", obj);
1293 }
1294 }
1295 return -1;
1296 }
1297
1298 /* Create a new array object */
1299 SWIGRUNTIME PyObject *
1300 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1301 PyObject *robj = 0;
1302 if (!type) {
1303 if (!PyErr_Occurred()) {
1304 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1305 }
1306 return robj;
1307 }
1308 if (!ptr) {
1309 Py_INCREF(Py_None);
1310 return Py_None;
1311 }
1312 #ifdef SWIG_COBJECT_TYPES
1313 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1314 #else
1315 {
1316 char result[SWIG_BUFFER_SIZE];
1317 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1318 PyString_FromString(result) : 0;
1319 }
1320 #endif
1321 if (!robj || (robj == Py_None)) return robj;
1322 if (type->clientdata) {
1323 PyObject *inst;
1324 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1325 Py_DECREF(robj);
1326 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1327 Py_DECREF(args);
1328 if (inst) {
1329 if (own) {
1330 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1331 }
1332 robj = inst;
1333 }
1334 }
1335 return robj;
1336 }
1337
1338 SWIGRUNTIME PyObject *
1339 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1340 PyObject *robj = 0;
1341 if (!ptr) {
1342 Py_INCREF(Py_None);
1343 return Py_None;
1344 }
1345 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1346 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1347 #else
1348 {
1349 char result[SWIG_BUFFER_SIZE];
1350 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1351 PyString_FromString(result) : 0;
1352 }
1353 #endif
1354 return robj;
1355 }
1356
1357 /* -----------------------------------------------------------------------------*
1358 * Get type list
1359 * -----------------------------------------------------------------------------*/
1360
1361 #ifdef SWIG_LINK_RUNTIME
1362 void *SWIG_ReturnGlobalTypeList(void *);
1363 #endif
1364
1365 SWIGRUNTIME swig_module_info *
1366 SWIG_Python_GetModule(void) {
1367 static void *type_pointer = (void *)0;
1368 /* first check if module already created */
1369 if (!type_pointer) {
1370 #ifdef SWIG_LINK_RUNTIME
1371 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1372 #else
1373 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1374 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1375 if (PyErr_Occurred()) {
1376 PyErr_Clear();
1377 type_pointer = (void *)0;
1378 }
1379 #endif
1380 }
1381 return (swig_module_info *) type_pointer;
1382 }
1383
1384 #if PY_MAJOR_VERSION < 2
1385 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1386 is copied out of Python/modsupport.c in python version 2.3.4 */
1387 SWIGINTERN int
1388 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1389 {
1390 PyObject *dict;
1391 if (!PyModule_Check(m)) {
1392 PyErr_SetString(PyExc_TypeError,
1393 "PyModule_AddObject() needs module as first arg");
1394 return -1;
1395 }
1396 if (!o) {
1397 PyErr_SetString(PyExc_TypeError,
1398 "PyModule_AddObject() needs non-NULL value");
1399 return -1;
1400 }
1401
1402 dict = PyModule_GetDict(m);
1403 if (dict == NULL) {
1404 /* Internal error -- modules must have a dict! */
1405 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1406 PyModule_GetName(m));
1407 return -1;
1408 }
1409 if (PyDict_SetItemString(dict, name, o))
1410 return -1;
1411 Py_DECREF(o);
1412 return 0;
1413 }
1414 #endif
1415
1416 SWIGRUNTIME void
1417 SWIG_Python_SetModule(swig_module_info *swig_module) {
1418 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1419
1420 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1421 swig_empty_runtime_method_table);
1422 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1423 if (pointer && module) {
1424 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1425 }
1426 }
1427
1428 #ifdef __cplusplus
1429 }
1430 #endif
1431
1432
1433 /* -------- TYPES TABLE (BEGIN) -------- */
1434
1435 #define SWIGTYPE_p_buffer swig_types[0]
1436 #define SWIGTYPE_p_char swig_types[1]
1437 #define SWIGTYPE_p_form_ops_t swig_types[2]
1438 #define SWIGTYPE_p_int swig_types[3]
1439 #define SWIGTYPE_p_long swig_types[4]
1440 #define SWIGTYPE_p_unsigned_char swig_types[5]
1441 #define SWIGTYPE_p_unsigned_int swig_types[6]
1442 #define SWIGTYPE_p_unsigned_long swig_types[7]
1443 #define SWIGTYPE_p_wxANIHandler swig_types[8]
1444 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
1445 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
1446 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
1447 #define SWIGTYPE_p_wxAppTraits swig_types[12]
1448 #define SWIGTYPE_p_wxArrayString swig_types[13]
1449 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
1450 #define SWIGTYPE_p_wxBitmap swig_types[15]
1451 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
1452 #define SWIGTYPE_p_wxButton swig_types[17]
1453 #define SWIGTYPE_p_wxCURHandler swig_types[18]
1454 #define SWIGTYPE_p_wxCaret swig_types[19]
1455 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
1457 #define SWIGTYPE_p_wxColour swig_types[22]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
1459 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
1460 #define SWIGTYPE_p_wxControl swig_types[25]
1461 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
1462 #define SWIGTYPE_p_wxCursor swig_types[27]
1463 #define SWIGTYPE_p_wxDC swig_types[28]
1464 #define SWIGTYPE_p_wxDateEvent swig_types[29]
1465 #define SWIGTYPE_p_wxDateTime swig_types[30]
1466 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
1467 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
1468 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
1469 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
1470 #define SWIGTYPE_p_wxEvent swig_types[35]
1471 #define SWIGTYPE_p_wxEventLoop swig_types[36]
1472 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
1473 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
1474 #define SWIGTYPE_p_wxFSFile swig_types[39]
1475 #define SWIGTYPE_p_wxFileSystem swig_types[40]
1476 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
1477 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
1478 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
1479 #define SWIGTYPE_p_wxFont swig_types[44]
1480 #define SWIGTYPE_p_wxFrame swig_types[45]
1481 #define SWIGTYPE_p_wxGBPosition swig_types[46]
1482 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
1483 #define SWIGTYPE_p_wxGBSpan swig_types[48]
1484 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
1485 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
1486 #define SWIGTYPE_p_wxGridSizer swig_types[51]
1487 #define SWIGTYPE_p_wxICOHandler swig_types[52]
1488 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
1489 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
1490 #define SWIGTYPE_p_wxImage swig_types[55]
1491 #define SWIGTYPE_p_wxImageHandler swig_types[56]
1492 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
1493 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
1494 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
1495 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
1496 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
1497 #define SWIGTYPE_p_wxInputStream swig_types[62]
1498 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
1499 #define SWIGTYPE_p_wxItemContainer swig_types[64]
1500 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1501 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
1502 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
1503 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
1504 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1505 #define SWIGTYPE_p_wxMenu swig_types[70]
1506 #define SWIGTYPE_p_wxMenuBar swig_types[71]
1507 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
1508 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
1509 #define SWIGTYPE_p_wxMenuItem swig_types[74]
1510 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
1511 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
1512 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
1513 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
1514 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
1515 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
1516 #define SWIGTYPE_p_wxObject swig_types[81]
1517 #define SWIGTYPE_p_wxOutputStream swig_types[82]
1518 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
1519 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
1520 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
1521 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
1522 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
1523 #define SWIGTYPE_p_wxPaperSize swig_types[88]
1524 #define SWIGTYPE_p_wxPoint swig_types[89]
1525 #define SWIGTYPE_p_wxPoint2D swig_types[90]
1526 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
1527 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
1528 #define SWIGTYPE_p_wxPyApp swig_types[93]
1529 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
1530 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
1531 #define SWIGTYPE_p_wxPyEvent swig_types[96]
1532 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
1533 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
1534 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
1535 #define SWIGTYPE_p_wxPySizer swig_types[100]
1536 #define SWIGTYPE_p_wxPyValidator swig_types[101]
1537 #define SWIGTYPE_p_wxQuantize swig_types[102]
1538 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
1539 #define SWIGTYPE_p_wxRealPoint swig_types[104]
1540 #define SWIGTYPE_p_wxRect swig_types[105]
1541 #define SWIGTYPE_p_wxRegion swig_types[106]
1542 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
1543 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
1544 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
1545 #define SWIGTYPE_p_wxShowEvent swig_types[110]
1546 #define SWIGTYPE_p_wxSize swig_types[111]
1547 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
1548 #define SWIGTYPE_p_wxSizer swig_types[113]
1549 #define SWIGTYPE_p_wxSizerItem swig_types[114]
1550 #define SWIGTYPE_p_wxStaticBox swig_types[115]
1551 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
1552 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
1553 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
1554 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
1555 #define SWIGTYPE_p_wxToolTip swig_types[120]
1556 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
1557 #define SWIGTYPE_p_wxValidator swig_types[122]
1558 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
1559 #define SWIGTYPE_p_wxWindow swig_types[124]
1560 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
1561 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
1562 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
1563 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
1564 #define SWIGTYPE_ptrdiff_t swig_types[129]
1565 #define SWIGTYPE_std__ptrdiff_t swig_types[130]
1566 #define SWIGTYPE_unsigned_int swig_types[131]
1567 static swig_type_info *swig_types[133];
1568 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
1569 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1570 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1571
1572 /* -------- TYPES TABLE (END) -------- */
1573
1574
1575 /*-----------------------------------------------
1576 @(target):= _core_.so
1577 ------------------------------------------------*/
1578 #define SWIG_init init_core_
1579
1580 #define SWIG_name "_core_"
1581
1582 #include "wx/wxPython/wxPython_int.h"
1583 #include "wx/wxPython/pyclasses.h"
1584
1585
1586 #ifndef wxPyUSE_EXPORT
1587 // Helper functions for dealing with SWIG objects and such. These are
1588 // located here so they know about the SWIG types and functions declared
1589 // in the wrapper code.
1590
1591 #include <wx/hashmap.h>
1592 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1593
1594
1595 // Maintains a hashmap of className to swig_type_info pointers. Given the
1596 // name of a class either looks up the type info in the cache, or scans the
1597 // SWIG tables for it.
1598 extern PyObject* wxPyPtrTypeMap;
1599 static
1600 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1601
1602 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1603
1604 if (typeInfoCache == NULL)
1605 typeInfoCache = new wxPyTypeInfoHashMap;
1606
1607 wxString name(className);
1608 swig_type_info* swigType = (*typeInfoCache)[name];
1609
1610 if (! swigType) {
1611 // it wasn't in the cache, so look it up from SWIG
1612 name.Append(wxT(" *"));
1613 swigType = SWIG_TypeQuery(name.mb_str());
1614
1615 // if it still wasn't found, try looking for a mapped name
1616 if (!swigType) {
1617 PyObject* item;
1618 name = className;
1619
1620 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1621 (char*)(const char*)name.mbc_str())) != NULL) {
1622 name = wxString(PyString_AsString(item), *wxConvCurrent);
1623 name.Append(wxT(" *"));
1624 swigType = SWIG_TypeQuery(name.mb_str());
1625 }
1626 }
1627 if (swigType) {
1628 // and add it to the map if found
1629 (*typeInfoCache)[className] = swigType;
1630 }
1631 }
1632 return swigType;
1633 }
1634
1635
1636 // Check if a class name is a type known to SWIG
1637 bool wxPyCheckSwigType(const wxChar* className) {
1638
1639 swig_type_info* swigType = wxPyFindSwigType(className);
1640 return swigType != NULL;
1641 }
1642
1643
1644 // Given a pointer to a C++ object and a class name, construct a Python proxy
1645 // object for it.
1646 PyObject* wxPyConstructObject(void* ptr,
1647 const wxChar* className,
1648 int setThisOwn) {
1649
1650 swig_type_info* swigType = wxPyFindSwigType(className);
1651 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1652
1653 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1654 }
1655
1656
1657 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1658 // Ensures that the proxy object is of the specified (or derived) type. If
1659 // not able to perform the conversion then a Python exception is set and the
1660 // error should be handled properly in the caller. Returns True on success.
1661 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1662 const wxChar* className) {
1663
1664 swig_type_info* swigType = wxPyFindSwigType(className);
1665 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1666
1667 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1668 }
1669
1670
1671 // Make a SWIGified pointer object suitable for a .this attribute
1672 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1673
1674 PyObject* robj = NULL;
1675
1676 swig_type_info* swigType = wxPyFindSwigType(className);
1677 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
1678
1679 #if SWIG_VERSION < 0x010328
1680 #ifdef SWIG_COBJECT_TYPES
1681 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1682 #else
1683 {
1684 char result[1024];
1685 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1686 PyString_FromString(result) : 0;
1687 }
1688 #endif
1689 #else // SWIG_VERSION >= 1.3.28
1690 robj = PySwigObject_New(ptr, swigType, 0);
1691 #endif
1692 return robj;
1693 }
1694
1695
1696 // Python's PyInstance_Check does not return True for instances of new-style
1697 // classes. This should get close enough for both new and old classes but I
1698 // should re-evaluate the need for doing instance checks...
1699 bool wxPyInstance_Check(PyObject* obj) {
1700 return PyObject_HasAttrString(obj, "__class__") != 0;
1701 }
1702
1703
1704
1705 // This one checks if the object is an instance of a SWIG proxy class (it has
1706 // a .this attribute, and the .this attribute is a PySwigObject.)
1707 bool wxPySwigInstance_Check(PyObject* obj) {
1708 static PyObject* this_str = NULL;
1709 if (this_str == NULL)
1710 this_str = PyString_FromString("this");
1711
1712 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1713 if (this_attr) {
1714 bool retval = (PySwigObject_Check(this_attr) != 0);
1715 Py_DECREF(this_attr);
1716 return retval;
1717 }
1718
1719 PyErr_Clear();
1720 return false;
1721 }
1722
1723
1724
1725 // Export a C API in a struct. Other modules will be able to load this from
1726 // the wx._core_ module and will then have safe access to these functions,
1727 // even if they are located in another shared library.
1728 static wxPyCoreAPI API = {
1729
1730 wxPyCheckSwigType,
1731 wxPyConstructObject,
1732 wxPyConvertSwigPtr,
1733 wxPyMakeSwigPtr,
1734
1735 wxPyBeginAllowThreads,
1736 wxPyEndAllowThreads,
1737 wxPyBeginBlockThreads,
1738 wxPyEndBlockThreads,
1739
1740 wxPy_ConvertList,
1741
1742 wxString_in_helper,
1743 Py2wxString,
1744 wx2PyString,
1745
1746 byte_LIST_helper,
1747 int_LIST_helper,
1748 long_LIST_helper,
1749 string_LIST_helper,
1750 wxPoint_LIST_helper,
1751 wxBitmap_LIST_helper,
1752 wxString_LIST_helper,
1753 wxAcceleratorEntry_LIST_helper,
1754
1755 wxSize_helper,
1756 wxPoint_helper,
1757 wxRealPoint_helper,
1758 wxRect_helper,
1759 wxColour_helper,
1760 wxPoint2D_helper,
1761
1762 wxPySimple_typecheck,
1763 wxColour_typecheck,
1764
1765 wxPyCBH_setCallbackInfo,
1766 wxPyCBH_findCallback,
1767 wxPyCBH_callCallback,
1768 wxPyCBH_callCallbackObj,
1769 wxPyCBH_delete,
1770
1771 wxPyMake_wxObject,
1772 wxPyMake_wxSizer,
1773 wxPyPtrTypeMap_Add,
1774 wxPy2int_seq_helper,
1775 wxPy4int_seq_helper,
1776 wxArrayString2PyList_helper,
1777 wxArrayInt2PyList_helper,
1778
1779 wxPyClientData_dtor,
1780 wxPyUserData_dtor,
1781 wxPyOORClientData_dtor,
1782
1783 wxPyCBInputStream_create,
1784 wxPyCBInputStream_copy,
1785
1786 wxPyInstance_Check,
1787 wxPySwigInstance_Check,
1788
1789 wxPyCheckForApp
1790
1791 };
1792
1793 #endif
1794
1795
1796 #if !WXWIN_COMPATIBILITY_2_4
1797 #define wxHIDE_READONLY 0
1798 #endif
1799
1800
1801 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1802 #define SWIG_From_int PyInt_FromLong
1803 /*@@*/
1804
1805 static const wxString wxPyEmptyString(wxEmptyString);
1806 static wxString wxObject_GetClassName(wxObject *self){
1807 return self->GetClassInfo()->GetClassName();
1808 }
1809 static void wxObject_Destroy(wxObject *self){
1810 delete self;
1811 }
1812
1813 #ifndef __WXMAC__
1814 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1815 #endif
1816
1817
1818 #include <limits.h>
1819
1820
1821 SWIGINTERN int
1822 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1823 const char *errmsg)
1824 {
1825 if (value < min_value) {
1826 if (errmsg) {
1827 PyErr_Format(PyExc_OverflowError,
1828 "value %ld is less than '%s' minimum %ld",
1829 value, errmsg, min_value);
1830 }
1831 return 0;
1832 } else if (value > max_value) {
1833 if (errmsg) {
1834 PyErr_Format(PyExc_OverflowError,
1835 "value %ld is greater than '%s' maximum %ld",
1836 value, errmsg, max_value);
1837 }
1838 return 0;
1839 }
1840 return 1;
1841 }
1842
1843
1844 SWIGINTERN int
1845 SWIG_AsVal_long(PyObject* obj, long* val)
1846 {
1847 if (PyNumber_Check(obj)) {
1848 if (val) *val = PyInt_AsLong(obj);
1849 return 1;
1850 }
1851 else {
1852 SWIG_Python_TypeError("number", obj);
1853 }
1854 return 0;
1855 }
1856
1857
1858 #if INT_MAX != LONG_MAX
1859 SWIGINTERN int
1860 SWIG_AsVal_int(PyObject *obj, int *val)
1861 {
1862 const char* errmsg = val ? "int" : (char*)0;
1863 long v;
1864 if (SWIG_AsVal_long(obj, &v)) {
1865 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1866 if (val) *val = static_cast<int >(v);
1867 return 1;
1868 } else {
1869 return 0;
1870 }
1871 } else {
1872 PyErr_Clear();
1873 }
1874 if (val) {
1875 SWIG_type_error(errmsg, obj);
1876 }
1877 return 0;
1878 }
1879 #else
1880 SWIGINTERNINLINE int
1881 SWIG_AsVal_int(PyObject *obj, int *val)
1882 {
1883 return SWIG_AsVal_long(obj,(long*)val);
1884 }
1885 #endif
1886
1887
1888 SWIGINTERNINLINE int
1889 SWIG_As_int(PyObject* obj)
1890 {
1891 int v;
1892 if (!SWIG_AsVal_int(obj, &v)) {
1893 /*
1894 this is needed to make valgrind/purify happier.
1895 */
1896 memset((void*)&v, 0, sizeof(int));
1897 }
1898 return v;
1899 }
1900
1901
1902 SWIGINTERNINLINE int
1903 SWIG_Check_int(PyObject* obj)
1904 {
1905 return SWIG_AsVal_int(obj, (int*)0);
1906 }
1907
1908 static PyObject *wxSize_Get(wxSize *self){
1909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1910 PyObject* tup = PyTuple_New(2);
1911 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1912 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1913 wxPyEndBlockThreads(blocked);
1914 return tup;
1915 }
1916
1917 SWIGINTERN int
1918 SWIG_AsVal_double(PyObject *obj, double* val)
1919 {
1920 if (PyNumber_Check(obj)) {
1921 if (val) *val = PyFloat_AsDouble(obj);
1922 return 1;
1923 }
1924 else {
1925 SWIG_Python_TypeError("number", obj);
1926 }
1927 return 0;
1928 }
1929
1930
1931 SWIGINTERNINLINE double
1932 SWIG_As_double(PyObject* obj)
1933 {
1934 double v;
1935 if (!SWIG_AsVal_double(obj, &v)) {
1936 /*
1937 this is needed to make valgrind/purify happier.
1938 */
1939 memset((void*)&v, 0, sizeof(double));
1940 }
1941 return v;
1942 }
1943
1944
1945 SWIGINTERNINLINE int
1946 SWIG_Check_double(PyObject* obj)
1947 {
1948 return SWIG_AsVal_double(obj, (double*)0);
1949 }
1950
1951
1952 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1953 #define SWIG_From_double PyFloat_FromDouble
1954 /*@@*/
1955
1956 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1957 self->x = x;
1958 self->y = y;
1959 }
1960 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1961 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1962 PyObject* tup = PyTuple_New(2);
1963 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1964 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1965 wxPyEndBlockThreads(blocked);
1966 return tup;
1967 }
1968
1969 SWIGINTERNINLINE long
1970 SWIG_As_long(PyObject* obj)
1971 {
1972 long v;
1973 if (!SWIG_AsVal_long(obj, &v)) {
1974 /*
1975 this is needed to make valgrind/purify happier.
1976 */
1977 memset((void*)&v, 0, sizeof(long));
1978 }
1979 return v;
1980 }
1981
1982
1983 SWIGINTERNINLINE int
1984 SWIG_Check_long(PyObject* obj)
1985 {
1986 return SWIG_AsVal_long(obj, (long*)0);
1987 }
1988
1989 static void wxPoint_Set(wxPoint *self,long x,long y){
1990 self->x = x;
1991 self->y = y;
1992 }
1993 static PyObject *wxPoint_Get(wxPoint *self){
1994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1995 PyObject* tup = PyTuple_New(2);
1996 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1997 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1998 wxPyEndBlockThreads(blocked);
1999 return tup;
2000 }
2001 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
2002 self->x = x;
2003 self->y = y;
2004 self->width = width;
2005 self->height = height;
2006 }
2007 static PyObject *wxRect_Get(wxRect *self){
2008 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2009 PyObject* tup = PyTuple_New(4);
2010 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2011 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2012 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
2013 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
2014 wxPyEndBlockThreads(blocked);
2015 return tup;
2016 }
2017
2018 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
2019 wxRegion reg1(*r1);
2020 wxRegion reg2(*r2);
2021 wxRect dest(0,0,0,0);
2022 PyObject* obj;
2023
2024 reg1.Intersect(reg2);
2025 dest = reg1.GetBox();
2026
2027 if (dest != wxRect(0,0,0,0)) {
2028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2029 wxRect* newRect = new wxRect(dest);
2030 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
2031 wxPyEndBlockThreads(blocked);
2032 return obj;
2033 }
2034 Py_INCREF(Py_None);
2035 return Py_None;
2036 }
2037
2038
2039 static PyObject* t_output_helper(PyObject* result, PyObject* obj)
2040 {
2041 PyObject* o2;
2042 PyObject* o3;
2043 if (!result) {
2044 result = obj;
2045 } else if (result == Py_None) {
2046 Py_DECREF(result);
2047 result = obj;
2048 } else {
2049 if (!PyTuple_Check(result)) {
2050 o2 = result;
2051 result = PyTuple_New(1);
2052 PyTuple_SET_ITEM(result, 0, o2);
2053 }
2054 o3 = PyTuple_New(1);
2055 PyTuple_SetItem(o3, 0, obj);
2056 o2 = result;
2057 result = PySequence_Concat(o2, o3);
2058 Py_DECREF(o2);
2059 Py_DECREF(o3);
2060 }
2061 return result;
2062 }
2063
2064
2065 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
2066 self->m_x = x;
2067 self->m_y = y;
2068 }
2069 static PyObject *wxPoint2D_Get(wxPoint2D *self){
2070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2071 PyObject* tup = PyTuple_New(2);
2072 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
2073 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
2074 wxPyEndBlockThreads(blocked);
2075 return tup;
2076 }
2077
2078 #include "wx/wxPython/pyistream.h"
2079
2080 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
2081 wxInputStream* wxis = wxPyCBInputStream::create(p);
2082 if (wxis)
2083 return new wxPyInputStream(wxis);
2084 else
2085 return NULL;
2086 }
2087
2088 SWIGINTERNINLINE PyObject*
2089 SWIG_From_char(char c)
2090 {
2091 return PyString_FromStringAndSize(&c,1);
2092 }
2093
2094
2095 SWIGINTERNINLINE PyObject*
2096 SWIG_From_unsigned_SS_long(unsigned long value)
2097 {
2098 return (value > LONG_MAX) ?
2099 PyLong_FromUnsignedLong(value)
2100 : PyInt_FromLong(static_cast<long >(value));
2101 }
2102
2103
2104 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2105 SWIGINTERN int
2106 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2107 {
2108 static swig_type_info* pchar_info = 0;
2109 char* vptr = 0;
2110 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2111 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2112 if (cptr) *cptr = vptr;
2113 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2114 return SWIG_OLDOBJ;
2115 } else {
2116 PyErr_Clear();
2117 if (PyString_Check(obj)) {
2118 if (cptr) {
2119 *cptr = PyString_AS_STRING(obj);
2120 if (psize) {
2121 *psize = PyString_GET_SIZE(obj) + 1;
2122 }
2123 }
2124 return SWIG_PYSTR;
2125 }
2126 }
2127 if (cptr) {
2128 SWIG_type_error("char *", obj);
2129 }
2130 return 0;
2131 }
2132
2133
2134 SWIGINTERN int
2135 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2136 {
2137 char* cptr; size_t csize;
2138 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2139 /* in C you can do:
2140
2141 char x[5] = "hello";
2142
2143 ie, assing the array using an extra '0' char.
2144 */
2145 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2146 if (csize <= size) {
2147 if (val) {
2148 if (csize) memcpy(val, cptr, csize);
2149 if (csize < size) memset(val + csize, 0, size - csize);
2150 }
2151 return 1;
2152 }
2153 }
2154 if (val) {
2155 PyErr_Format(PyExc_TypeError,
2156 "a char array of maximum size %lu is expected",
2157 (unsigned long) size);
2158 }
2159 return 0;
2160 }
2161
2162
2163 SWIGINTERN int
2164 SWIG_AsVal_char(PyObject *obj, char *val)
2165 {
2166 const char* errmsg = val ? "char" : (char*)0;
2167 long v;
2168 if (SWIG_AsVal_long(obj, &v)) {
2169 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2170 if (val) *val = static_cast<char >(v);
2171 return 1;
2172 } else {
2173 return 0;
2174 }
2175 } else {
2176 PyErr_Clear();
2177 return SWIG_AsCharArray(obj, val, 1);
2178 }
2179 }
2180
2181
2182 SWIGINTERNINLINE char
2183 SWIG_As_char(PyObject* obj)
2184 {
2185 char v;
2186 if (!SWIG_AsVal_char(obj, &v)) {
2187 /*
2188 this is needed to make valgrind/purify happier.
2189 */
2190 memset((void*)&v, 0, sizeof(char));
2191 }
2192 return v;
2193 }
2194
2195
2196 SWIGINTERNINLINE int
2197 SWIG_Check_char(PyObject* obj)
2198 {
2199 return SWIG_AsVal_char(obj, (char*)0);
2200 }
2201
2202
2203 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2204 #define SWIG_From_long PyInt_FromLong
2205 /*@@*/
2206
2207 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2208 // We use only strings for the streams, not unicode
2209 PyObject* str = PyObject_Str(obj);
2210 if (! str) {
2211 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2212 return;
2213 }
2214 self->Write(PyString_AS_STRING(str),
2215 PyString_GET_SIZE(str));
2216 Py_DECREF(str);
2217 }
2218
2219 #include "wx/wxPython/pyistream.h"
2220
2221
2222 class wxPyFileSystemHandler : public wxFileSystemHandler
2223 {
2224 public:
2225 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2226
2227 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2228 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2229 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2230 DEC_PYCALLBACK_STRING__pure(FindNext);
2231
2232 wxString GetProtocol(const wxString& location) {
2233 return wxFileSystemHandler::GetProtocol(location);
2234 }
2235
2236 wxString GetLeftLocation(const wxString& location) {
2237 return wxFileSystemHandler::GetLeftLocation(location);
2238 }
2239
2240 wxString GetAnchor(const wxString& location) {
2241 return wxFileSystemHandler::GetAnchor(location);
2242 }
2243
2244 wxString GetRightLocation(const wxString& location) {
2245 return wxFileSystemHandler::GetRightLocation(location);
2246 }
2247
2248 wxString GetMimeTypeFromExt(const wxString& location) {
2249 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2250 }
2251
2252 PYPRIVATE;
2253 };
2254
2255
2256 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2257 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2258 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2259 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2260
2261
2262 SWIGINTERN int
2263 SWIG_AsVal_bool(PyObject *obj, bool *val)
2264 {
2265 if (obj == Py_True) {
2266 if (val) *val = true;
2267 return 1;
2268 }
2269 if (obj == Py_False) {
2270 if (val) *val = false;
2271 return 1;
2272 }
2273 int res = 0;
2274 if (SWIG_AsVal_int(obj, &res)) {
2275 if (val) *val = res ? true : false;
2276 return 1;
2277 } else {
2278 PyErr_Clear();
2279 }
2280 if (val) {
2281 SWIG_type_error("bool", obj);
2282 }
2283 return 0;
2284 }
2285
2286
2287 SWIGINTERNINLINE bool
2288 SWIG_As_bool(PyObject* obj)
2289 {
2290 bool v;
2291 if (!SWIG_AsVal_bool(obj, &v)) {
2292 /*
2293 this is needed to make valgrind/purify happier.
2294 */
2295 memset((void*)&v, 0, sizeof(bool));
2296 }
2297 return v;
2298 }
2299
2300
2301 SWIGINTERNINLINE int
2302 SWIG_Check_bool(PyObject* obj)
2303 {
2304 return SWIG_AsVal_bool(obj, (bool*)0);
2305 }
2306
2307 static wxString wxFileSystem_URLToFileName(wxString const &url){
2308 wxFileName fname = wxFileSystem::URLToFileName(url);
2309 return fname.GetFullPath();
2310 }
2311
2312 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2313 wxImage& image,
2314 long type) {
2315 wxMemoryFSHandler::AddFile(filename, image, type);
2316 }
2317
2318 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2319 const wxBitmap& bitmap,
2320 long type) {
2321 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2322 }
2323
2324 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2325 PyObject* data) {
2326 if (! PyString_Check(data)) {
2327 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2328 "Expected string object"));
2329 return;
2330 }
2331
2332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2333 void* ptr = (void*)PyString_AsString(data);
2334 size_t size = PyString_Size(data);
2335 wxPyEndBlockThreads(blocked);
2336
2337 wxMemoryFSHandler::AddFile(filename, ptr, size);
2338 }
2339
2340
2341 #include "wx/wxPython/pyistream.h"
2342
2343
2344 SWIGINTERN int
2345 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2346 {
2347 long v = 0;
2348 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2349 SWIG_Python_TypeError("unsigned number", obj);
2350 }
2351 else if (val)
2352 *val = (unsigned long)v;
2353 return 1;
2354 }
2355
2356
2357 SWIGINTERNINLINE int
2358 SWIG_CheckUnsignedLongInRange(unsigned long value,
2359 unsigned long max_value,
2360 const char *errmsg)
2361 {
2362 if (value > max_value) {
2363 if (errmsg) {
2364 PyErr_Format(PyExc_OverflowError,
2365 "value %lu is greater than '%s' minimum %lu",
2366 value, errmsg, max_value);
2367 }
2368 return 0;
2369 }
2370 return 1;
2371 }
2372
2373
2374 SWIGINTERN int
2375 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2376 {
2377 const char* errmsg = val ? "unsigned char" : (char*)0;
2378 unsigned long v;
2379 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2380 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2381 if (val) *val = static_cast<unsigned char >(v);
2382 return 1;
2383 } else {
2384 return 0;
2385 }
2386 } else {
2387 PyErr_Clear();
2388 }
2389 if (val) {
2390 SWIG_type_error(errmsg, obj);
2391 }
2392 return 0;
2393 }
2394
2395
2396 SWIGINTERNINLINE unsigned char
2397 SWIG_As_unsigned_SS_char(PyObject* obj)
2398 {
2399 unsigned char v;
2400 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2401 /*
2402 this is needed to make valgrind/purify happier.
2403 */
2404 memset((void*)&v, 0, sizeof(unsigned char));
2405 }
2406 return v;
2407 }
2408
2409
2410 SWIGINTERNINLINE int
2411 SWIG_Check_unsigned_SS_char(PyObject* obj)
2412 {
2413 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2414 }
2415
2416
2417 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2418 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2419 /*@@*/
2420
2421
2422
2423 SWIGINTERNINLINE unsigned long
2424 SWIG_As_unsigned_SS_long(PyObject* obj)
2425 {
2426 unsigned long v;
2427 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2428 /*
2429 this is needed to make valgrind/purify happier.
2430 */
2431 memset((void*)&v, 0, sizeof(unsigned long));
2432 }
2433 return v;
2434 }
2435
2436
2437 SWIGINTERNINLINE int
2438 SWIG_Check_unsigned_SS_long(PyObject* obj)
2439 {
2440 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2441 }
2442
2443 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2444 wxImageHistogramEntry e = (*self)[key];
2445 return e.value;
2446 }
2447 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2448 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2449 wxImageHistogramEntry e = (*self)[key];
2450 return e.value;
2451 }
2452 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2453 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2454 colour.Green(),
2455 colour.Blue());
2456 wxImageHistogramEntry e = (*self)[key];
2457 return e.value;
2458 }
2459
2460 typedef unsigned char* buffer;
2461
2462
2463 // Pull the nested class out to the top level for SWIG's sake
2464 #define wxImage_RGBValue wxImage::RGBValue
2465 #define wxImage_HSVValue wxImage::HSVValue
2466
2467 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2468 if (width > 0 && height > 0)
2469 return new wxImage(width, height, clear);
2470 else
2471 return new wxImage;
2472 }
2473 static wxImage *new_wxImage(wxBitmap const &bitmap){
2474 return new wxImage(bitmap.ConvertToImage());
2475 }
2476 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2477 if (DATASIZE != width*height*3) {
2478 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2479 return NULL;
2480 }
2481
2482 // Copy the source data so the wxImage can clean it up later
2483 buffer copy = (buffer)malloc(DATASIZE);
2484 if (copy == NULL) {
2485 wxPyBLOCK_THREADS(PyErr_NoMemory());
2486 return NULL;
2487 }
2488 memcpy(copy, data, DATASIZE);
2489 return new wxImage(width, height, copy, false);
2490 }
2491 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2492 if (DATASIZE != width*height*3) {
2493 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2494 return NULL;
2495 }
2496 if (ALPHASIZE != width*height) {
2497 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2498 return NULL;
2499 }
2500
2501 // Copy the source data so the wxImage can clean it up later
2502 buffer dcopy = (buffer)malloc(DATASIZE);
2503 if (dcopy == NULL) {
2504 wxPyBLOCK_THREADS(PyErr_NoMemory());
2505 return NULL;
2506 }
2507 memcpy(dcopy, data, DATASIZE);
2508
2509 buffer acopy = (buffer)malloc(ALPHASIZE);
2510 if (acopy == NULL) {
2511 wxPyBLOCK_THREADS(PyErr_NoMemory());
2512 return NULL;
2513 }
2514 memcpy(acopy, alpha, ALPHASIZE);
2515
2516 return new wxImage(width, height, dcopy, acopy, false);
2517 }
2518 static wxSize wxImage_GetSize(wxImage *self){
2519 wxSize size(self->GetWidth(), self->GetHeight());
2520 return size;
2521 }
2522 static PyObject *wxImage_GetData(wxImage *self){
2523 buffer data = self->GetData();
2524 int len = self->GetWidth() * self->GetHeight() * 3;
2525 PyObject* rv;
2526 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2527 return rv;
2528 }
2529 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2530 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2531 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2532 return;
2533 }
2534 buffer copy = (buffer)malloc(DATASIZE);
2535 if (copy == NULL) {
2536 wxPyBLOCK_THREADS(PyErr_NoMemory());
2537 return;
2538 }
2539 memcpy(copy, data, DATASIZE);
2540 self->SetData(copy, false);
2541 // wxImage takes ownership of copy...
2542 }
2543 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2544 buffer data = self->GetData();
2545 int len = self->GetWidth() * self->GetHeight() * 3;
2546 PyObject* rv;
2547 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2548 return rv;
2549 }
2550 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2551 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2552 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2553 return;
2554 }
2555 self->SetData(data, true);
2556 }
2557 static PyObject *wxImage_GetAlphaData(wxImage *self){
2558 buffer data = self->GetAlpha();
2559 if (! data) {
2560 RETURN_NONE();
2561 } else {
2562 int len = self->GetWidth() * self->GetHeight();
2563 PyObject* rv;
2564 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2565 return rv;
2566 }
2567 }
2568 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2569 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2570 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2571 return;
2572 }
2573 buffer acopy = (buffer)malloc(ALPHASIZE);
2574 if (acopy == NULL) {
2575 wxPyBLOCK_THREADS(PyErr_NoMemory());
2576 return;
2577 }
2578 memcpy(acopy, alpha, ALPHASIZE);
2579 self->SetAlpha(acopy, false);
2580 // wxImage takes ownership of acopy...
2581 }
2582 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2583 buffer data = self->GetAlpha();
2584 int len = self->GetWidth() * self->GetHeight();
2585 PyObject* rv;
2586 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2587 return rv;
2588 }
2589 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2590 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2591 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2592 return;
2593 }
2594 self->SetAlpha(alpha, true);
2595 }
2596 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2597 wxBitmap bitmap(*self, depth);
2598 return bitmap;
2599 }
2600 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2601 wxImage mono = self->ConvertToMono( red, green, blue );
2602 wxBitmap bitmap( mono, 1 );
2603 return bitmap;
2604 }
2605 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2606 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2607 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2608 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2609 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2610 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2611 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2612 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2613 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2614 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2615 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2616 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2617 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2618 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2619 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2620
2621 #include <wx/quantize.h>
2622
2623 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2624 return wxQuantize::Quantize(src, dest,
2625 //NULL, // palette
2626 desiredNoColours,
2627 NULL, // eightBitData
2628 flags);
2629 }
2630 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2631 if (PyCallable_Check(func)) {
2632 self->Connect(id, lastId, eventType,
2633 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2634 new wxPyCallback(func));
2635 }
2636 else if (func == Py_None) {
2637 self->Disconnect(id, lastId, eventType,
2638 (wxObjectEventFunction)
2639 &wxPyCallback::EventThunker);
2640 }
2641 else {
2642 wxPyBLOCK_THREADS(
2643 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2644 }
2645 }
2646 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2647 return self->Disconnect(id, lastId, eventType,
2648 (wxObjectEventFunction)
2649 &wxPyCallback::EventThunker);
2650 }
2651 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2652 if (_self && _self != Py_None) {
2653 self->SetClientObject(new wxPyOORClientData(_self, incref));
2654 }
2655 else {
2656 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2657 if (data) {
2658 self->SetClientObject(NULL); // This will delete it too
2659 }
2660 }
2661 }
2662
2663 #if ! wxUSE_HOTKEY
2664 #define wxEVT_HOTKEY -9999
2665 #endif
2666
2667
2668 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2669 #if wxUSE_UNICODE
2670 return self->GetUnicodeKey();
2671 #else
2672 return 0;
2673 #endif
2674 }
2675
2676 #if UINT_MAX < LONG_MAX
2677 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2678 #define SWIG_From_unsigned_SS_int SWIG_From_long
2679 /*@@*/
2680 #else
2681 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2682 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2683 /*@@*/
2684 #endif
2685
2686
2687 #if UINT_MAX != ULONG_MAX
2688 SWIGINTERN int
2689 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2690 {
2691 const char* errmsg = val ? "unsigned int" : (char*)0;
2692 unsigned long v;
2693 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2694 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2695 if (val) *val = static_cast<unsigned int >(v);
2696 return 1;
2697 }
2698 } else {
2699 PyErr_Clear();
2700 }
2701 if (val) {
2702 SWIG_type_error(errmsg, obj);
2703 }
2704 return 0;
2705 }
2706 #else
2707 SWIGINTERNINLINE unsigned int
2708 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2709 {
2710 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2711 }
2712 #endif
2713
2714
2715 SWIGINTERNINLINE unsigned int
2716 SWIG_As_unsigned_SS_int(PyObject* obj)
2717 {
2718 unsigned int v;
2719 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2720 /*
2721 this is needed to make valgrind/purify happier.
2722 */
2723 memset((void*)&v, 0, sizeof(unsigned int));
2724 }
2725 return v;
2726 }
2727
2728
2729 SWIGINTERNINLINE int
2730 SWIG_Check_unsigned_SS_int(PyObject* obj)
2731 {
2732 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2733 }
2734
2735 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2736 self->m_size = size;
2737 }
2738 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2739 int count = self->GetNumberOfFiles();
2740 wxString* files = self->GetFiles();
2741 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2742 PyObject* list = PyList_New(count);
2743
2744 if (!list) {
2745 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2746 wxPyEndBlockThreads(blocked);
2747 return NULL;
2748 }
2749
2750 for (int i=0; i<count; i++) {
2751 PyList_SetItem(list, i, wx2PyString(files[i]));
2752 }
2753 wxPyEndBlockThreads(blocked);
2754 return list;
2755 }
2756
2757
2758 static wxPyApp *new_wxPyApp(){
2759 wxPythonApp = new wxPyApp();
2760 return wxPythonApp;
2761 }
2762 static int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2763
2764 void wxApp_CleanUp() {
2765 __wxPyCleanup();
2766 }
2767
2768
2769 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2770
2771
2772 SWIGINTERNINLINE int
2773 SWIG_AsCharPtr(PyObject *obj, char **val)
2774 {
2775 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2776 return 1;
2777 }
2778 if (val) {
2779 PyErr_Clear();
2780 SWIG_type_error("char *", obj);
2781 }
2782 return 0;
2783 }
2784
2785
2786 SWIGINTERN PyObject *
2787 SWIG_FromCharPtr(const char* cptr)
2788 {
2789 if (cptr) {
2790 size_t size = strlen(cptr);
2791 if (size > INT_MAX) {
2792 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2793 SWIG_TypeQuery("char *"), 0);
2794 } else {
2795 if (size != 0) {
2796 return PyString_FromStringAndSize(cptr, size);
2797 } else {
2798 return PyString_FromString(cptr);
2799 }
2800 }
2801 }
2802 Py_INCREF(Py_None);
2803 return Py_None;
2804 }
2805
2806
2807 #if 0 // #ifdef __WXMAC__
2808
2809 // A dummy class that raises an exception if used...
2810 class wxEventLoop
2811 {
2812 public:
2813 wxEventLoop() { wxPyRaiseNotImplemented(); }
2814 int Run() { return 0; }
2815 void Exit(int rc = 0) {}
2816 bool Pending() const { return false; }
2817 bool Dispatch() { return false; }
2818 bool IsRunning() const { return false; }
2819 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2820 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2821 };
2822
2823 #else
2824
2825 #include <wx/evtloop.h>
2826
2827 #endif
2828
2829
2830
2831 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2832 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2833 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2834 static PyObject *wxWindow_GetChildren(wxWindow *self){
2835 wxWindowList& list = self->GetChildren();
2836 return wxPy_ConvertList(&list);
2837 }
2838 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2839 #if wxUSE_HOTKEY
2840 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2841 #else
2842 return false;
2843 #endif
2844 }
2845 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2846
2847
2848
2849 return false;
2850
2851 }
2852 static long wxWindow_GetHandle(wxWindow *self){
2853 return wxPyGetWinHandle(self);
2854 }
2855 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2856 self->AssociateHandle((WXWidget)handle);
2857 }
2858 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
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 wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2918 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2919 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2920 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2921 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2922 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2923 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
2924 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2925 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2926 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2927 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2928 static int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
2929 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2930 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2931 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2932 static const wxString wxPyControlNameStr(wxControlNameStr);
2933 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2934 if (clientData) {
2935 wxPyClientData* data = new wxPyClientData(clientData);
2936 return self->Append(item, data);
2937 } else
2938 return self->Append(item);
2939 }
2940 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2941 if (clientData) {
2942 wxPyClientData* data = new wxPyClientData(clientData);
2943 return self->Insert(item, pos, data);
2944 } else
2945 return self->Insert(item, pos);
2946 }
2947 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2948 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2949 if (data) {
2950 Py_INCREF(data->m_obj);
2951 return data->m_obj;
2952 } else {
2953 Py_INCREF(Py_None);
2954 return Py_None;
2955 }
2956 }
2957 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2958 wxPyClientData* data = new wxPyClientData(clientData);
2959 self->SetClientObject(n, data);
2960 }
2961
2962
2963 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2964 wxPyUserData* data = NULL;
2965 if ( userData ) {
2966 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2967 data = new wxPyUserData(userData);
2968 wxPyEndBlockThreads(blocked);
2969 }
2970 return new wxSizerItem(window, proportion, flag, border, data);
2971 }
2972 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2973 wxPyUserData* data = NULL;
2974 if ( userData ) {
2975 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2976 data = new wxPyUserData(userData);
2977 wxPyEndBlockThreads(blocked);
2978 }
2979 return new wxSizerItem(width, height, proportion, flag, border, data);
2980 }
2981 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2982 wxPyUserData* data = NULL;
2983 if ( userData ) {
2984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2985 data = new wxPyUserData(userData);
2986 wxPyEndBlockThreads(blocked);
2987 }
2988 return new wxSizerItem(sizer, proportion, flag, border, data);
2989 }
2990
2991 #include <float.h>
2992 SWIGINTERN int
2993 SWIG_CheckDoubleInRange(double value, double min_value,
2994 double max_value, const char* errmsg)
2995 {
2996 if (value < min_value) {
2997 if (errmsg) {
2998 PyErr_Format(PyExc_OverflowError,
2999 "value %g is less than %s minimum %g",
3000 value, errmsg, min_value);
3001 }
3002 return 0;
3003 } else if (value > max_value) {
3004 if (errmsg) {
3005 PyErr_Format(PyExc_OverflowError,
3006 "value %g is greater than %s maximum %g",
3007 value, errmsg, max_value);
3008 }
3009 return 0;
3010 }
3011 return 1;
3012 }
3013
3014
3015 SWIGINTERN int
3016 SWIG_AsVal_float(PyObject *obj, float *val)
3017 {
3018 const char* errmsg = val ? "float" : (char*)0;
3019 double v;
3020 if (SWIG_AsVal_double(obj, &v)) {
3021 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3022 if (val) *val = static_cast<float >(v);
3023 return 1;
3024 } else {
3025 return 0;
3026 }
3027 } else {
3028 PyErr_Clear();
3029 }
3030 if (val) {
3031 SWIG_type_error(errmsg, obj);
3032 }
3033 return 0;
3034 }
3035
3036
3037 SWIGINTERNINLINE float
3038 SWIG_As_float(PyObject* obj)
3039 {
3040 float v;
3041 if (!SWIG_AsVal_float(obj, &v)) {
3042 /*
3043 this is needed to make valgrind/purify happier.
3044 */
3045 memset((void*)&v, 0, sizeof(float));
3046 }
3047 return v;
3048 }
3049
3050
3051 SWIGINTERNINLINE int
3052 SWIG_Check_float(PyObject* obj)
3053 {
3054 return SWIG_AsVal_float(obj, (float*)0);
3055 }
3056
3057
3058 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
3059 #define SWIG_From_float PyFloat_FromDouble
3060 /*@@*/
3061
3062 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3063 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3064 if (data) {
3065 Py_INCREF(data->m_obj);
3066 return data->m_obj;
3067 } else {
3068 Py_INCREF(Py_None);
3069 return Py_None;
3070 }
3071 }
3072 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3073 wxPyUserData* data = NULL;
3074 if ( userData ) {
3075 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3076 data = new wxPyUserData(userData);
3077 wxPyEndBlockThreads(blocked);
3078 }
3079 self->SetUserData(data);
3080 }
3081
3082 // Figure out the type of the sizer item
3083
3084 struct wxPySizerItemInfo {
3085 wxPySizerItemInfo()
3086 : window(NULL), sizer(NULL), gotSize(false),
3087 size(wxDefaultSize), gotPos(false), pos(-1)
3088 {}
3089
3090 wxWindow* window;
3091 wxSizer* sizer;
3092 bool gotSize;
3093 wxSize size;
3094 bool gotPos;
3095 int pos;
3096 };
3097
3098 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3099
3100 wxPySizerItemInfo info;
3101 wxSize size;
3102 wxSize* sizePtr = &size;
3103
3104 // Find out what the type of the item is
3105 // try wxWindow
3106 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3107 PyErr_Clear();
3108 info.window = NULL;
3109
3110 // try wxSizer
3111 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3112 PyErr_Clear();
3113 info.sizer = NULL;
3114
3115 // try wxSize or (w,h)
3116 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3117 info.size = *sizePtr;
3118 info.gotSize = true;
3119 }
3120
3121 // or a single int
3122 if (checkIdx && PyInt_Check(item)) {
3123 info.pos = PyInt_AsLong(item);
3124 info.gotPos = true;
3125 }
3126 }
3127 }
3128
3129 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3130 // no expected type, figure out what kind of error message to generate
3131 if ( !checkSize && !checkIdx )
3132 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3133 else if ( checkSize && !checkIdx )
3134 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3135 else if ( !checkSize && checkIdx)
3136 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3137 else
3138 // can this one happen?
3139 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3140 }
3141
3142 return info;
3143 }
3144
3145 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3146 if (!self->GetClientObject())
3147 self->SetClientObject(new wxPyOORClientData(_self));
3148 }
3149 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3150
3151 wxPyUserData* data = NULL;
3152 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3153 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3154 if ( userData && (info.window || info.sizer || info.gotSize) )
3155 data = new wxPyUserData(userData);
3156 if ( info.sizer )
3157 PyObject_SetAttrString(item,"thisown",Py_False);
3158 wxPyEndBlockThreads(blocked);
3159
3160 // Now call the real Add method if a valid item type was found
3161 if ( info.window )
3162 return self->Add(info.window, proportion, flag, border, data);
3163 else if ( info.sizer )
3164 return self->Add(info.sizer, proportion, flag, border, data);
3165 else if (info.gotSize)
3166 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3167 proportion, flag, border, data);
3168 else
3169 return NULL;
3170 }
3171 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3172
3173 wxPyUserData* data = NULL;
3174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3175 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3176 if ( userData && (info.window || info.sizer || info.gotSize) )
3177 data = new wxPyUserData(userData);
3178 if ( info.sizer )
3179 PyObject_SetAttrString(item,"thisown",Py_False);
3180 wxPyEndBlockThreads(blocked);
3181
3182 // Now call the real Insert method if a valid item type was found
3183 if ( info.window )
3184 return self->Insert(before, info.window, proportion, flag, border, data);
3185 else if ( info.sizer )
3186 return self->Insert(before, info.sizer, proportion, flag, border, data);
3187 else if (info.gotSize)
3188 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3189 proportion, flag, border, data);
3190 else
3191 return NULL;
3192 }
3193 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3194
3195 wxPyUserData* data = NULL;
3196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3198 if ( userData && (info.window || info.sizer || info.gotSize) )
3199 data = new wxPyUserData(userData);
3200 if ( info.sizer )
3201 PyObject_SetAttrString(item,"thisown",Py_False);
3202 wxPyEndBlockThreads(blocked);
3203
3204 // Now call the real Prepend method if a valid item type was found
3205 if ( info.window )
3206 return self->Prepend(info.window, proportion, flag, border, data);
3207 else if ( info.sizer )
3208 return self->Prepend(info.sizer, proportion, flag, border, data);
3209 else if (info.gotSize)
3210 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3211 proportion, flag, border, data);
3212 else
3213 return NULL;
3214 }
3215 static bool wxSizer_Remove(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->Remove(info.window);
3221 else if ( info.sizer )
3222 return self->Remove(info.sizer);
3223 else if ( info.gotPos )
3224 return self->Remove(info.pos);
3225 else
3226 return false;
3227 }
3228 static bool wxSizer_Detach(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->Detach(info.window);
3234 else if ( info.sizer )
3235 return self->Detach(info.sizer);
3236 else if ( info.gotPos )
3237 return self->Detach(info.pos);
3238 else
3239 return false;
3240 }
3241 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3242 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3243 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3244 wxPyEndBlockThreads(blocked);
3245 if ( info.window )
3246 return self->GetItem(info.window);
3247 else if ( info.sizer )
3248 return self->GetItem(info.sizer);
3249 else if ( info.gotPos )
3250 return self->GetItem(info.pos);
3251 else
3252 return NULL;
3253 }
3254 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3255 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3256 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3257 wxPyEndBlockThreads(blocked);
3258 if ( info.window )
3259 self->SetItemMinSize(info.window, size);
3260 else if ( info.sizer )
3261 self->SetItemMinSize(info.sizer, size);
3262 else if ( info.gotPos )
3263 self->SetItemMinSize(info.pos, size);
3264 }
3265 static PyObject *wxSizer_GetChildren(wxSizer *self){
3266 wxSizerItemList& list = self->GetChildren();
3267 return wxPy_ConvertList(&list);
3268 }
3269 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3270 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3271 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3272 wxPyEndBlockThreads(blocked);
3273 if ( info.window )
3274 return self->Show(info.window, show, recursive);
3275 else if ( info.sizer )
3276 return self->Show(info.sizer, show, recursive);
3277 else if ( info.gotPos )
3278 return self->Show(info.pos, show);
3279 else
3280 return false;
3281 }
3282 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3284 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3285 wxPyEndBlockThreads(blocked);
3286 if ( info.window )
3287 return self->IsShown(info.window);
3288 else if ( info.sizer )
3289 return self->IsShown(info.sizer);
3290 else if ( info.gotPos )
3291 return self->IsShown(info.pos);
3292 else
3293 return false;
3294 }
3295
3296 // See pyclasses.h
3297 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3298 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3299 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3300
3301
3302
3303
3304 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3305 {
3306 if (source == Py_None) {
3307 **obj = wxGBPosition(-1,-1);
3308 return true;
3309 }
3310 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3311 }
3312
3313 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3314 {
3315 if (source == Py_None) {
3316 **obj = wxGBSpan(-1,-1);
3317 return true;
3318 }
3319 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3320 }
3321
3322
3323 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3324 self->SetRow(row);
3325 self->SetCol(col);
3326 }
3327 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3328 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3329 PyObject* tup = PyTuple_New(2);
3330 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3331 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3332 wxPyEndBlockThreads(blocked);
3333 return tup;
3334 }
3335 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3336 self->SetRowspan(rowspan);
3337 self->SetColspan(colspan);
3338 }
3339 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3341 PyObject* tup = PyTuple_New(2);
3342 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3343 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3344 wxPyEndBlockThreads(blocked);
3345 return tup;
3346 }
3347 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3348 wxPyUserData* data = NULL;
3349 if ( userData ) {
3350 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3351 data = new wxPyUserData(userData);
3352 wxPyEndBlockThreads(blocked);
3353 }
3354 return new wxGBSizerItem(window, pos, span, flag, border, data);
3355 }
3356 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3357 wxPyUserData* data = NULL;
3358 if ( userData ) {
3359 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3360 data = new wxPyUserData(userData);
3361 wxPyEndBlockThreads(blocked);
3362 }
3363 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3364 }
3365 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3366 wxPyUserData* data = NULL;
3367 if ( userData ) {
3368 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3369 data = new wxPyUserData(userData);
3370 wxPyEndBlockThreads(blocked);
3371 }
3372 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3373 }
3374 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3375 int row, col;
3376 self->GetEndPos(row, col);
3377 return wxGBPosition(row, col);
3378 }
3379 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3380
3381 wxPyUserData* data = NULL;
3382 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3383 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3384 if ( userData && (info.window || info.sizer || info.gotSize) )
3385 data = new wxPyUserData(userData);
3386 if ( info.sizer )
3387 PyObject_SetAttrString(item,"thisown",Py_False);
3388 wxPyEndBlockThreads(blocked);
3389
3390 // Now call the real Add method if a valid item type was found
3391 if ( info.window )
3392 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3393 else if ( info.sizer )
3394 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3395 else if (info.gotSize)
3396 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3397 pos, span, flag, border, data);
3398 return NULL;
3399 }
3400
3401
3402 #ifdef __cplusplus
3403 extern "C" {
3404 #endif
3405 static int _wrap_EmptyString_set(PyObject *) {
3406 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3407 return 1;
3408 }
3409
3410
3411 static PyObject *_wrap_EmptyString_get(void) {
3412 PyObject *pyobj = NULL;
3413
3414 {
3415 #if wxUSE_UNICODE
3416 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3417 #else
3418 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3419 #endif
3420 }
3421 return pyobj;
3422 }
3423
3424
3425 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3426 PyObject *resultobj = NULL;
3427 wxObject *arg1 = (wxObject *) 0 ;
3428 wxString result;
3429 PyObject * obj0 = 0 ;
3430 char *kwnames[] = {
3431 (char *) "self", NULL
3432 };
3433
3434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3436 if (SWIG_arg_fail(1)) SWIG_fail;
3437 {
3438 PyThreadState* __tstate = wxPyBeginAllowThreads();
3439 result = wxObject_GetClassName(arg1);
3440
3441 wxPyEndAllowThreads(__tstate);
3442 if (PyErr_Occurred()) SWIG_fail;
3443 }
3444 {
3445 #if wxUSE_UNICODE
3446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3447 #else
3448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3449 #endif
3450 }
3451 return resultobj;
3452 fail:
3453 return NULL;
3454 }
3455
3456
3457 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3458 PyObject *resultobj = NULL;
3459 wxObject *arg1 = (wxObject *) 0 ;
3460 PyObject * obj0 = 0 ;
3461 char *kwnames[] = {
3462 (char *) "self", NULL
3463 };
3464
3465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3467 if (SWIG_arg_fail(1)) SWIG_fail;
3468 {
3469 PyThreadState* __tstate = wxPyBeginAllowThreads();
3470 wxObject_Destroy(arg1);
3471
3472 wxPyEndAllowThreads(__tstate);
3473 if (PyErr_Occurred()) SWIG_fail;
3474 }
3475 Py_INCREF(Py_None); resultobj = Py_None;
3476 return resultobj;
3477 fail:
3478 return NULL;
3479 }
3480
3481
3482 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3483 PyObject *obj;
3484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3485 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3486 Py_INCREF(obj);
3487 return Py_BuildValue((char *)"");
3488 }
3489 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3490 PyObject *resultobj = NULL;
3491 wxSize *arg1 = (wxSize *) 0 ;
3492 int arg2 ;
3493 PyObject * obj0 = 0 ;
3494 PyObject * obj1 = 0 ;
3495 char *kwnames[] = {
3496 (char *) "self",(char *) "x", NULL
3497 };
3498
3499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3501 if (SWIG_arg_fail(1)) SWIG_fail;
3502 {
3503 arg2 = static_cast<int >(SWIG_As_int(obj1));
3504 if (SWIG_arg_fail(2)) SWIG_fail;
3505 }
3506 if (arg1) (arg1)->x = arg2;
3507
3508 Py_INCREF(Py_None); resultobj = Py_None;
3509 return resultobj;
3510 fail:
3511 return NULL;
3512 }
3513
3514
3515 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3516 PyObject *resultobj = NULL;
3517 wxSize *arg1 = (wxSize *) 0 ;
3518 int result;
3519 PyObject * obj0 = 0 ;
3520 char *kwnames[] = {
3521 (char *) "self", NULL
3522 };
3523
3524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3526 if (SWIG_arg_fail(1)) SWIG_fail;
3527 result = (int) ((arg1)->x);
3528
3529 {
3530 resultobj = SWIG_From_int(static_cast<int >(result));
3531 }
3532 return resultobj;
3533 fail:
3534 return NULL;
3535 }
3536
3537
3538 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3539 PyObject *resultobj = NULL;
3540 wxSize *arg1 = (wxSize *) 0 ;
3541 int arg2 ;
3542 PyObject * obj0 = 0 ;
3543 PyObject * obj1 = 0 ;
3544 char *kwnames[] = {
3545 (char *) "self",(char *) "y", NULL
3546 };
3547
3548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3550 if (SWIG_arg_fail(1)) SWIG_fail;
3551 {
3552 arg2 = static_cast<int >(SWIG_As_int(obj1));
3553 if (SWIG_arg_fail(2)) SWIG_fail;
3554 }
3555 if (arg1) (arg1)->y = arg2;
3556
3557 Py_INCREF(Py_None); resultobj = Py_None;
3558 return resultobj;
3559 fail:
3560 return NULL;
3561 }
3562
3563
3564 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3565 PyObject *resultobj = NULL;
3566 wxSize *arg1 = (wxSize *) 0 ;
3567 int result;
3568 PyObject * obj0 = 0 ;
3569 char *kwnames[] = {
3570 (char *) "self", NULL
3571 };
3572
3573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3575 if (SWIG_arg_fail(1)) SWIG_fail;
3576 result = (int) ((arg1)->y);
3577
3578 {
3579 resultobj = SWIG_From_int(static_cast<int >(result));
3580 }
3581 return resultobj;
3582 fail:
3583 return NULL;
3584 }
3585
3586
3587 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3588 PyObject *resultobj = NULL;
3589 int arg1 = (int) 0 ;
3590 int arg2 = (int) 0 ;
3591 wxSize *result;
3592 PyObject * obj0 = 0 ;
3593 PyObject * obj1 = 0 ;
3594 char *kwnames[] = {
3595 (char *) "w",(char *) "h", NULL
3596 };
3597
3598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3599 if (obj0) {
3600 {
3601 arg1 = static_cast<int >(SWIG_As_int(obj0));
3602 if (SWIG_arg_fail(1)) SWIG_fail;
3603 }
3604 }
3605 if (obj1) {
3606 {
3607 arg2 = static_cast<int >(SWIG_As_int(obj1));
3608 if (SWIG_arg_fail(2)) SWIG_fail;
3609 }
3610 }
3611 {
3612 PyThreadState* __tstate = wxPyBeginAllowThreads();
3613 result = (wxSize *)new wxSize(arg1,arg2);
3614
3615 wxPyEndAllowThreads(__tstate);
3616 if (PyErr_Occurred()) SWIG_fail;
3617 }
3618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3619 return resultobj;
3620 fail:
3621 return NULL;
3622 }
3623
3624
3625 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3626 PyObject *resultobj = NULL;
3627 wxSize *arg1 = (wxSize *) 0 ;
3628 PyObject * obj0 = 0 ;
3629 char *kwnames[] = {
3630 (char *) "self", NULL
3631 };
3632
3633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3635 if (SWIG_arg_fail(1)) SWIG_fail;
3636 {
3637 PyThreadState* __tstate = wxPyBeginAllowThreads();
3638 delete arg1;
3639
3640 wxPyEndAllowThreads(__tstate);
3641 if (PyErr_Occurred()) SWIG_fail;
3642 }
3643 Py_INCREF(Py_None); resultobj = Py_None;
3644 return resultobj;
3645 fail:
3646 return NULL;
3647 }
3648
3649
3650 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3651 PyObject *resultobj = NULL;
3652 wxSize *arg1 = (wxSize *) 0 ;
3653 wxSize *arg2 = 0 ;
3654 bool result;
3655 wxSize temp2 ;
3656 PyObject * obj0 = 0 ;
3657 PyObject * obj1 = 0 ;
3658 char *kwnames[] = {
3659 (char *) "self",(char *) "sz", NULL
3660 };
3661
3662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3664 if (SWIG_arg_fail(1)) SWIG_fail;
3665 {
3666 arg2 = &temp2;
3667 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3668 }
3669 {
3670 PyThreadState* __tstate = wxPyBeginAllowThreads();
3671 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3672
3673 wxPyEndAllowThreads(__tstate);
3674 if (PyErr_Occurred()) SWIG_fail;
3675 }
3676 {
3677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3678 }
3679 return resultobj;
3680 fail:
3681 return NULL;
3682 }
3683
3684
3685 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3686 PyObject *resultobj = NULL;
3687 wxSize *arg1 = (wxSize *) 0 ;
3688 wxSize *arg2 = 0 ;
3689 bool result;
3690 wxSize temp2 ;
3691 PyObject * obj0 = 0 ;
3692 PyObject * obj1 = 0 ;
3693 char *kwnames[] = {
3694 (char *) "self",(char *) "sz", NULL
3695 };
3696
3697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3699 if (SWIG_arg_fail(1)) SWIG_fail;
3700 {
3701 arg2 = &temp2;
3702 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3703 }
3704 {
3705 PyThreadState* __tstate = wxPyBeginAllowThreads();
3706 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3707
3708 wxPyEndAllowThreads(__tstate);
3709 if (PyErr_Occurred()) SWIG_fail;
3710 }
3711 {
3712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3713 }
3714 return resultobj;
3715 fail:
3716 return NULL;
3717 }
3718
3719
3720 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3721 PyObject *resultobj = NULL;
3722 wxSize *arg1 = (wxSize *) 0 ;
3723 wxSize *arg2 = 0 ;
3724 wxSize result;
3725 wxSize temp2 ;
3726 PyObject * obj0 = 0 ;
3727 PyObject * obj1 = 0 ;
3728 char *kwnames[] = {
3729 (char *) "self",(char *) "sz", NULL
3730 };
3731
3732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3734 if (SWIG_arg_fail(1)) SWIG_fail;
3735 {
3736 arg2 = &temp2;
3737 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3738 }
3739 {
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 result = (arg1)->operator +((wxSize const &)*arg2);
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 {
3747 wxSize * resultptr;
3748 resultptr = new wxSize(static_cast<wxSize & >(result));
3749 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3750 }
3751 return resultobj;
3752 fail:
3753 return NULL;
3754 }
3755
3756
3757 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3758 PyObject *resultobj = NULL;
3759 wxSize *arg1 = (wxSize *) 0 ;
3760 wxSize *arg2 = 0 ;
3761 wxSize result;
3762 wxSize temp2 ;
3763 PyObject * obj0 = 0 ;
3764 PyObject * obj1 = 0 ;
3765 char *kwnames[] = {
3766 (char *) "self",(char *) "sz", NULL
3767 };
3768
3769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3771 if (SWIG_arg_fail(1)) SWIG_fail;
3772 {
3773 arg2 = &temp2;
3774 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3775 }
3776 {
3777 PyThreadState* __tstate = wxPyBeginAllowThreads();
3778 result = (arg1)->operator -((wxSize const &)*arg2);
3779
3780 wxPyEndAllowThreads(__tstate);
3781 if (PyErr_Occurred()) SWIG_fail;
3782 }
3783 {
3784 wxSize * resultptr;
3785 resultptr = new wxSize(static_cast<wxSize & >(result));
3786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3787 }
3788 return resultobj;
3789 fail:
3790 return NULL;
3791 }
3792
3793
3794 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3795 PyObject *resultobj = NULL;
3796 wxSize *arg1 = (wxSize *) 0 ;
3797 wxSize *arg2 = 0 ;
3798 wxSize temp2 ;
3799 PyObject * obj0 = 0 ;
3800 PyObject * obj1 = 0 ;
3801 char *kwnames[] = {
3802 (char *) "self",(char *) "sz", NULL
3803 };
3804
3805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3807 if (SWIG_arg_fail(1)) SWIG_fail;
3808 {
3809 arg2 = &temp2;
3810 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3811 }
3812 {
3813 PyThreadState* __tstate = wxPyBeginAllowThreads();
3814 (arg1)->IncTo((wxSize const &)*arg2);
3815
3816 wxPyEndAllowThreads(__tstate);
3817 if (PyErr_Occurred()) SWIG_fail;
3818 }
3819 Py_INCREF(Py_None); resultobj = Py_None;
3820 return resultobj;
3821 fail:
3822 return NULL;
3823 }
3824
3825
3826 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3827 PyObject *resultobj = NULL;
3828 wxSize *arg1 = (wxSize *) 0 ;
3829 wxSize *arg2 = 0 ;
3830 wxSize temp2 ;
3831 PyObject * obj0 = 0 ;
3832 PyObject * obj1 = 0 ;
3833 char *kwnames[] = {
3834 (char *) "self",(char *) "sz", NULL
3835 };
3836
3837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3839 if (SWIG_arg_fail(1)) SWIG_fail;
3840 {
3841 arg2 = &temp2;
3842 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3843 }
3844 {
3845 PyThreadState* __tstate = wxPyBeginAllowThreads();
3846 (arg1)->DecTo((wxSize const &)*arg2);
3847
3848 wxPyEndAllowThreads(__tstate);
3849 if (PyErr_Occurred()) SWIG_fail;
3850 }
3851 Py_INCREF(Py_None); resultobj = Py_None;
3852 return resultobj;
3853 fail:
3854 return NULL;
3855 }
3856
3857
3858 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3859 PyObject *resultobj = NULL;
3860 wxSize *arg1 = (wxSize *) 0 ;
3861 int arg2 ;
3862 int arg3 ;
3863 PyObject * obj0 = 0 ;
3864 PyObject * obj1 = 0 ;
3865 PyObject * obj2 = 0 ;
3866 char *kwnames[] = {
3867 (char *) "self",(char *) "w",(char *) "h", NULL
3868 };
3869
3870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3872 if (SWIG_arg_fail(1)) SWIG_fail;
3873 {
3874 arg2 = static_cast<int >(SWIG_As_int(obj1));
3875 if (SWIG_arg_fail(2)) SWIG_fail;
3876 }
3877 {
3878 arg3 = static_cast<int >(SWIG_As_int(obj2));
3879 if (SWIG_arg_fail(3)) SWIG_fail;
3880 }
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 (arg1)->Set(arg2,arg3);
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 Py_INCREF(Py_None); resultobj = Py_None;
3889 return resultobj;
3890 fail:
3891 return NULL;
3892 }
3893
3894
3895 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3896 PyObject *resultobj = NULL;
3897 wxSize *arg1 = (wxSize *) 0 ;
3898 int arg2 ;
3899 PyObject * obj0 = 0 ;
3900 PyObject * obj1 = 0 ;
3901 char *kwnames[] = {
3902 (char *) "self",(char *) "w", NULL
3903 };
3904
3905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3907 if (SWIG_arg_fail(1)) SWIG_fail;
3908 {
3909 arg2 = static_cast<int >(SWIG_As_int(obj1));
3910 if (SWIG_arg_fail(2)) SWIG_fail;
3911 }
3912 {
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 (arg1)->SetWidth(arg2);
3915
3916 wxPyEndAllowThreads(__tstate);
3917 if (PyErr_Occurred()) SWIG_fail;
3918 }
3919 Py_INCREF(Py_None); resultobj = Py_None;
3920 return resultobj;
3921 fail:
3922 return NULL;
3923 }
3924
3925
3926 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3927 PyObject *resultobj = NULL;
3928 wxSize *arg1 = (wxSize *) 0 ;
3929 int arg2 ;
3930 PyObject * obj0 = 0 ;
3931 PyObject * obj1 = 0 ;
3932 char *kwnames[] = {
3933 (char *) "self",(char *) "h", NULL
3934 };
3935
3936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3938 if (SWIG_arg_fail(1)) SWIG_fail;
3939 {
3940 arg2 = static_cast<int >(SWIG_As_int(obj1));
3941 if (SWIG_arg_fail(2)) SWIG_fail;
3942 }
3943 {
3944 PyThreadState* __tstate = wxPyBeginAllowThreads();
3945 (arg1)->SetHeight(arg2);
3946
3947 wxPyEndAllowThreads(__tstate);
3948 if (PyErr_Occurred()) SWIG_fail;
3949 }
3950 Py_INCREF(Py_None); resultobj = Py_None;
3951 return resultobj;
3952 fail:
3953 return NULL;
3954 }
3955
3956
3957 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3958 PyObject *resultobj = NULL;
3959 wxSize *arg1 = (wxSize *) 0 ;
3960 int result;
3961 PyObject * obj0 = 0 ;
3962 char *kwnames[] = {
3963 (char *) "self", NULL
3964 };
3965
3966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3968 if (SWIG_arg_fail(1)) SWIG_fail;
3969 {
3970 PyThreadState* __tstate = wxPyBeginAllowThreads();
3971 result = (int)((wxSize const *)arg1)->GetWidth();
3972
3973 wxPyEndAllowThreads(__tstate);
3974 if (PyErr_Occurred()) SWIG_fail;
3975 }
3976 {
3977 resultobj = SWIG_From_int(static_cast<int >(result));
3978 }
3979 return resultobj;
3980 fail:
3981 return NULL;
3982 }
3983
3984
3985 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3986 PyObject *resultobj = NULL;
3987 wxSize *arg1 = (wxSize *) 0 ;
3988 int result;
3989 PyObject * obj0 = 0 ;
3990 char *kwnames[] = {
3991 (char *) "self", NULL
3992 };
3993
3994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3996 if (SWIG_arg_fail(1)) SWIG_fail;
3997 {
3998 PyThreadState* __tstate = wxPyBeginAllowThreads();
3999 result = (int)((wxSize const *)arg1)->GetHeight();
4000
4001 wxPyEndAllowThreads(__tstate);
4002 if (PyErr_Occurred()) SWIG_fail;
4003 }
4004 {
4005 resultobj = SWIG_From_int(static_cast<int >(result));
4006 }
4007 return resultobj;
4008 fail:
4009 return NULL;
4010 }
4011
4012
4013 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
4014 PyObject *resultobj = NULL;
4015 wxSize *arg1 = (wxSize *) 0 ;
4016 bool result;
4017 PyObject * obj0 = 0 ;
4018 char *kwnames[] = {
4019 (char *) "self", NULL
4020 };
4021
4022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
4023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4024 if (SWIG_arg_fail(1)) SWIG_fail;
4025 {
4026 PyThreadState* __tstate = wxPyBeginAllowThreads();
4027 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4028
4029 wxPyEndAllowThreads(__tstate);
4030 if (PyErr_Occurred()) SWIG_fail;
4031 }
4032 {
4033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4034 }
4035 return resultobj;
4036 fail:
4037 return NULL;
4038 }
4039
4040
4041 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4042 PyObject *resultobj = NULL;
4043 wxSize *arg1 = (wxSize *) 0 ;
4044 wxSize *arg2 = 0 ;
4045 wxSize temp2 ;
4046 PyObject * obj0 = 0 ;
4047 PyObject * obj1 = 0 ;
4048 char *kwnames[] = {
4049 (char *) "self",(char *) "size", NULL
4050 };
4051
4052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4054 if (SWIG_arg_fail(1)) SWIG_fail;
4055 {
4056 arg2 = &temp2;
4057 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4058 }
4059 {
4060 PyThreadState* __tstate = wxPyBeginAllowThreads();
4061 (arg1)->SetDefaults((wxSize const &)*arg2);
4062
4063 wxPyEndAllowThreads(__tstate);
4064 if (PyErr_Occurred()) SWIG_fail;
4065 }
4066 Py_INCREF(Py_None); resultobj = Py_None;
4067 return resultobj;
4068 fail:
4069 return NULL;
4070 }
4071
4072
4073 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4074 PyObject *resultobj = NULL;
4075 wxSize *arg1 = (wxSize *) 0 ;
4076 PyObject *result;
4077 PyObject * obj0 = 0 ;
4078 char *kwnames[] = {
4079 (char *) "self", NULL
4080 };
4081
4082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4084 if (SWIG_arg_fail(1)) SWIG_fail;
4085 {
4086 PyThreadState* __tstate = wxPyBeginAllowThreads();
4087 result = (PyObject *)wxSize_Get(arg1);
4088
4089 wxPyEndAllowThreads(__tstate);
4090 if (PyErr_Occurred()) SWIG_fail;
4091 }
4092 resultobj = result;
4093 return resultobj;
4094 fail:
4095 return NULL;
4096 }
4097
4098
4099 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4100 PyObject *obj;
4101 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4102 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4103 Py_INCREF(obj);
4104 return Py_BuildValue((char *)"");
4105 }
4106 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4107 PyObject *resultobj = NULL;
4108 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4109 double arg2 ;
4110 PyObject * obj0 = 0 ;
4111 PyObject * obj1 = 0 ;
4112 char *kwnames[] = {
4113 (char *) "self",(char *) "x", NULL
4114 };
4115
4116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4118 if (SWIG_arg_fail(1)) SWIG_fail;
4119 {
4120 arg2 = static_cast<double >(SWIG_As_double(obj1));
4121 if (SWIG_arg_fail(2)) SWIG_fail;
4122 }
4123 if (arg1) (arg1)->x = arg2;
4124
4125 Py_INCREF(Py_None); resultobj = Py_None;
4126 return resultobj;
4127 fail:
4128 return NULL;
4129 }
4130
4131
4132 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4133 PyObject *resultobj = NULL;
4134 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4135 double result;
4136 PyObject * obj0 = 0 ;
4137 char *kwnames[] = {
4138 (char *) "self", NULL
4139 };
4140
4141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4143 if (SWIG_arg_fail(1)) SWIG_fail;
4144 result = (double) ((arg1)->x);
4145
4146 {
4147 resultobj = SWIG_From_double(static_cast<double >(result));
4148 }
4149 return resultobj;
4150 fail:
4151 return NULL;
4152 }
4153
4154
4155 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4156 PyObject *resultobj = NULL;
4157 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4158 double arg2 ;
4159 PyObject * obj0 = 0 ;
4160 PyObject * obj1 = 0 ;
4161 char *kwnames[] = {
4162 (char *) "self",(char *) "y", NULL
4163 };
4164
4165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4167 if (SWIG_arg_fail(1)) SWIG_fail;
4168 {
4169 arg2 = static_cast<double >(SWIG_As_double(obj1));
4170 if (SWIG_arg_fail(2)) SWIG_fail;
4171 }
4172 if (arg1) (arg1)->y = arg2;
4173
4174 Py_INCREF(Py_None); resultobj = Py_None;
4175 return resultobj;
4176 fail:
4177 return NULL;
4178 }
4179
4180
4181 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4182 PyObject *resultobj = NULL;
4183 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4184 double result;
4185 PyObject * obj0 = 0 ;
4186 char *kwnames[] = {
4187 (char *) "self", NULL
4188 };
4189
4190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4192 if (SWIG_arg_fail(1)) SWIG_fail;
4193 result = (double) ((arg1)->y);
4194
4195 {
4196 resultobj = SWIG_From_double(static_cast<double >(result));
4197 }
4198 return resultobj;
4199 fail:
4200 return NULL;
4201 }
4202
4203
4204 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4205 PyObject *resultobj = NULL;
4206 double arg1 = (double) 0.0 ;
4207 double arg2 = (double) 0.0 ;
4208 wxRealPoint *result;
4209 PyObject * obj0 = 0 ;
4210 PyObject * obj1 = 0 ;
4211 char *kwnames[] = {
4212 (char *) "x",(char *) "y", NULL
4213 };
4214
4215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4216 if (obj0) {
4217 {
4218 arg1 = static_cast<double >(SWIG_As_double(obj0));
4219 if (SWIG_arg_fail(1)) SWIG_fail;
4220 }
4221 }
4222 if (obj1) {
4223 {
4224 arg2 = static_cast<double >(SWIG_As_double(obj1));
4225 if (SWIG_arg_fail(2)) SWIG_fail;
4226 }
4227 }
4228 {
4229 PyThreadState* __tstate = wxPyBeginAllowThreads();
4230 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4231
4232 wxPyEndAllowThreads(__tstate);
4233 if (PyErr_Occurred()) SWIG_fail;
4234 }
4235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4236 return resultobj;
4237 fail:
4238 return NULL;
4239 }
4240
4241
4242 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4243 PyObject *resultobj = NULL;
4244 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4245 PyObject * obj0 = 0 ;
4246 char *kwnames[] = {
4247 (char *) "self", NULL
4248 };
4249
4250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4252 if (SWIG_arg_fail(1)) SWIG_fail;
4253 {
4254 PyThreadState* __tstate = wxPyBeginAllowThreads();
4255 delete arg1;
4256
4257 wxPyEndAllowThreads(__tstate);
4258 if (PyErr_Occurred()) SWIG_fail;
4259 }
4260 Py_INCREF(Py_None); resultobj = Py_None;
4261 return resultobj;
4262 fail:
4263 return NULL;
4264 }
4265
4266
4267 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4268 PyObject *resultobj = NULL;
4269 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4270 wxRealPoint *arg2 = 0 ;
4271 bool result;
4272 wxRealPoint temp2 ;
4273 PyObject * obj0 = 0 ;
4274 PyObject * obj1 = 0 ;
4275 char *kwnames[] = {
4276 (char *) "self",(char *) "pt", NULL
4277 };
4278
4279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4281 if (SWIG_arg_fail(1)) SWIG_fail;
4282 {
4283 arg2 = &temp2;
4284 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4285 }
4286 {
4287 PyThreadState* __tstate = wxPyBeginAllowThreads();
4288 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4289
4290 wxPyEndAllowThreads(__tstate);
4291 if (PyErr_Occurred()) SWIG_fail;
4292 }
4293 {
4294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4295 }
4296 return resultobj;
4297 fail:
4298 return NULL;
4299 }
4300
4301
4302 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4303 PyObject *resultobj = NULL;
4304 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4305 wxRealPoint *arg2 = 0 ;
4306 bool result;
4307 wxRealPoint temp2 ;
4308 PyObject * obj0 = 0 ;
4309 PyObject * obj1 = 0 ;
4310 char *kwnames[] = {
4311 (char *) "self",(char *) "pt", NULL
4312 };
4313
4314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4316 if (SWIG_arg_fail(1)) SWIG_fail;
4317 {
4318 arg2 = &temp2;
4319 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4320 }
4321 {
4322 PyThreadState* __tstate = wxPyBeginAllowThreads();
4323 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4324
4325 wxPyEndAllowThreads(__tstate);
4326 if (PyErr_Occurred()) SWIG_fail;
4327 }
4328 {
4329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4330 }
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj = NULL;
4339 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4340 wxRealPoint *arg2 = 0 ;
4341 wxRealPoint result;
4342 wxRealPoint temp2 ;
4343 PyObject * obj0 = 0 ;
4344 PyObject * obj1 = 0 ;
4345 char *kwnames[] = {
4346 (char *) "self",(char *) "pt", NULL
4347 };
4348
4349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4351 if (SWIG_arg_fail(1)) SWIG_fail;
4352 {
4353 arg2 = &temp2;
4354 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4355 }
4356 {
4357 PyThreadState* __tstate = wxPyBeginAllowThreads();
4358 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4359
4360 wxPyEndAllowThreads(__tstate);
4361 if (PyErr_Occurred()) SWIG_fail;
4362 }
4363 {
4364 wxRealPoint * resultptr;
4365 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4367 }
4368 return resultobj;
4369 fail:
4370 return NULL;
4371 }
4372
4373
4374 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4375 PyObject *resultobj = NULL;
4376 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4377 wxRealPoint *arg2 = 0 ;
4378 wxRealPoint result;
4379 wxRealPoint temp2 ;
4380 PyObject * obj0 = 0 ;
4381 PyObject * obj1 = 0 ;
4382 char *kwnames[] = {
4383 (char *) "self",(char *) "pt", NULL
4384 };
4385
4386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4388 if (SWIG_arg_fail(1)) SWIG_fail;
4389 {
4390 arg2 = &temp2;
4391 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4392 }
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4396
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 {
4401 wxRealPoint * resultptr;
4402 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4404 }
4405 return resultobj;
4406 fail:
4407 return NULL;
4408 }
4409
4410
4411 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4412 PyObject *resultobj = NULL;
4413 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4414 double arg2 ;
4415 double arg3 ;
4416 PyObject * obj0 = 0 ;
4417 PyObject * obj1 = 0 ;
4418 PyObject * obj2 = 0 ;
4419 char *kwnames[] = {
4420 (char *) "self",(char *) "x",(char *) "y", NULL
4421 };
4422
4423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4425 if (SWIG_arg_fail(1)) SWIG_fail;
4426 {
4427 arg2 = static_cast<double >(SWIG_As_double(obj1));
4428 if (SWIG_arg_fail(2)) SWIG_fail;
4429 }
4430 {
4431 arg3 = static_cast<double >(SWIG_As_double(obj2));
4432 if (SWIG_arg_fail(3)) SWIG_fail;
4433 }
4434 {
4435 PyThreadState* __tstate = wxPyBeginAllowThreads();
4436 wxRealPoint_Set(arg1,arg2,arg3);
4437
4438 wxPyEndAllowThreads(__tstate);
4439 if (PyErr_Occurred()) SWIG_fail;
4440 }
4441 Py_INCREF(Py_None); resultobj = Py_None;
4442 return resultobj;
4443 fail:
4444 return NULL;
4445 }
4446
4447
4448 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4449 PyObject *resultobj = NULL;
4450 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4451 PyObject *result;
4452 PyObject * obj0 = 0 ;
4453 char *kwnames[] = {
4454 (char *) "self", NULL
4455 };
4456
4457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4459 if (SWIG_arg_fail(1)) SWIG_fail;
4460 {
4461 PyThreadState* __tstate = wxPyBeginAllowThreads();
4462 result = (PyObject *)wxRealPoint_Get(arg1);
4463
4464 wxPyEndAllowThreads(__tstate);
4465 if (PyErr_Occurred()) SWIG_fail;
4466 }
4467 resultobj = result;
4468 return resultobj;
4469 fail:
4470 return NULL;
4471 }
4472
4473
4474 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4475 PyObject *obj;
4476 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4477 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4478 Py_INCREF(obj);
4479 return Py_BuildValue((char *)"");
4480 }
4481 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4482 PyObject *resultobj = NULL;
4483 wxPoint *arg1 = (wxPoint *) 0 ;
4484 int arg2 ;
4485 PyObject * obj0 = 0 ;
4486 PyObject * obj1 = 0 ;
4487 char *kwnames[] = {
4488 (char *) "self",(char *) "x", NULL
4489 };
4490
4491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4493 if (SWIG_arg_fail(1)) SWIG_fail;
4494 {
4495 arg2 = static_cast<int >(SWIG_As_int(obj1));
4496 if (SWIG_arg_fail(2)) SWIG_fail;
4497 }
4498 if (arg1) (arg1)->x = arg2;
4499
4500 Py_INCREF(Py_None); resultobj = Py_None;
4501 return resultobj;
4502 fail:
4503 return NULL;
4504 }
4505
4506
4507 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4508 PyObject *resultobj = NULL;
4509 wxPoint *arg1 = (wxPoint *) 0 ;
4510 int result;
4511 PyObject * obj0 = 0 ;
4512 char *kwnames[] = {
4513 (char *) "self", NULL
4514 };
4515
4516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4518 if (SWIG_arg_fail(1)) SWIG_fail;
4519 result = (int) ((arg1)->x);
4520
4521 {
4522 resultobj = SWIG_From_int(static_cast<int >(result));
4523 }
4524 return resultobj;
4525 fail:
4526 return NULL;
4527 }
4528
4529
4530 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4531 PyObject *resultobj = NULL;
4532 wxPoint *arg1 = (wxPoint *) 0 ;
4533 int arg2 ;
4534 PyObject * obj0 = 0 ;
4535 PyObject * obj1 = 0 ;
4536 char *kwnames[] = {
4537 (char *) "self",(char *) "y", NULL
4538 };
4539
4540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4542 if (SWIG_arg_fail(1)) SWIG_fail;
4543 {
4544 arg2 = static_cast<int >(SWIG_As_int(obj1));
4545 if (SWIG_arg_fail(2)) SWIG_fail;
4546 }
4547 if (arg1) (arg1)->y = arg2;
4548
4549 Py_INCREF(Py_None); resultobj = Py_None;
4550 return resultobj;
4551 fail:
4552 return NULL;
4553 }
4554
4555
4556 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4557 PyObject *resultobj = NULL;
4558 wxPoint *arg1 = (wxPoint *) 0 ;
4559 int result;
4560 PyObject * obj0 = 0 ;
4561 char *kwnames[] = {
4562 (char *) "self", NULL
4563 };
4564
4565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4567 if (SWIG_arg_fail(1)) SWIG_fail;
4568 result = (int) ((arg1)->y);
4569
4570 {
4571 resultobj = SWIG_From_int(static_cast<int >(result));
4572 }
4573 return resultobj;
4574 fail:
4575 return NULL;
4576 }
4577
4578
4579 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4580 PyObject *resultobj = NULL;
4581 int arg1 = (int) 0 ;
4582 int arg2 = (int) 0 ;
4583 wxPoint *result;
4584 PyObject * obj0 = 0 ;
4585 PyObject * obj1 = 0 ;
4586 char *kwnames[] = {
4587 (char *) "x",(char *) "y", NULL
4588 };
4589
4590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4591 if (obj0) {
4592 {
4593 arg1 = static_cast<int >(SWIG_As_int(obj0));
4594 if (SWIG_arg_fail(1)) SWIG_fail;
4595 }
4596 }
4597 if (obj1) {
4598 {
4599 arg2 = static_cast<int >(SWIG_As_int(obj1));
4600 if (SWIG_arg_fail(2)) SWIG_fail;
4601 }
4602 }
4603 {
4604 PyThreadState* __tstate = wxPyBeginAllowThreads();
4605 result = (wxPoint *)new wxPoint(arg1,arg2);
4606
4607 wxPyEndAllowThreads(__tstate);
4608 if (PyErr_Occurred()) SWIG_fail;
4609 }
4610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4611 return resultobj;
4612 fail:
4613 return NULL;
4614 }
4615
4616
4617 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4618 PyObject *resultobj = NULL;
4619 wxPoint *arg1 = (wxPoint *) 0 ;
4620 PyObject * obj0 = 0 ;
4621 char *kwnames[] = {
4622 (char *) "self", NULL
4623 };
4624
4625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4627 if (SWIG_arg_fail(1)) SWIG_fail;
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 delete arg1;
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 Py_INCREF(Py_None); resultobj = Py_None;
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj = NULL;
4644 wxPoint *arg1 = (wxPoint *) 0 ;
4645 wxPoint *arg2 = 0 ;
4646 bool result;
4647 wxPoint temp2 ;
4648 PyObject * obj0 = 0 ;
4649 PyObject * obj1 = 0 ;
4650 char *kwnames[] = {
4651 (char *) "self",(char *) "pt", NULL
4652 };
4653
4654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4656 if (SWIG_arg_fail(1)) SWIG_fail;
4657 {
4658 arg2 = &temp2;
4659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4660 }
4661 {
4662 PyThreadState* __tstate = wxPyBeginAllowThreads();
4663 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4664
4665 wxPyEndAllowThreads(__tstate);
4666 if (PyErr_Occurred()) SWIG_fail;
4667 }
4668 {
4669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4670 }
4671 return resultobj;
4672 fail:
4673 return NULL;
4674 }
4675
4676
4677 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4678 PyObject *resultobj = NULL;
4679 wxPoint *arg1 = (wxPoint *) 0 ;
4680 wxPoint *arg2 = 0 ;
4681 bool result;
4682 wxPoint temp2 ;
4683 PyObject * obj0 = 0 ;
4684 PyObject * obj1 = 0 ;
4685 char *kwnames[] = {
4686 (char *) "self",(char *) "pt", NULL
4687 };
4688
4689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4691 if (SWIG_arg_fail(1)) SWIG_fail;
4692 {
4693 arg2 = &temp2;
4694 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4695 }
4696 {
4697 PyThreadState* __tstate = wxPyBeginAllowThreads();
4698 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4699
4700 wxPyEndAllowThreads(__tstate);
4701 if (PyErr_Occurred()) SWIG_fail;
4702 }
4703 {
4704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4705 }
4706 return resultobj;
4707 fail:
4708 return NULL;
4709 }
4710
4711
4712 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4713 PyObject *resultobj = NULL;
4714 wxPoint *arg1 = (wxPoint *) 0 ;
4715 wxPoint *arg2 = 0 ;
4716 wxPoint result;
4717 wxPoint temp2 ;
4718 PyObject * obj0 = 0 ;
4719 PyObject * obj1 = 0 ;
4720 char *kwnames[] = {
4721 (char *) "self",(char *) "pt", NULL
4722 };
4723
4724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4726 if (SWIG_arg_fail(1)) SWIG_fail;
4727 {
4728 arg2 = &temp2;
4729 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4730 }
4731 {
4732 PyThreadState* __tstate = wxPyBeginAllowThreads();
4733 result = (arg1)->operator +((wxPoint const &)*arg2);
4734
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 {
4739 wxPoint * resultptr;
4740 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4741 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4742 }
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4750 PyObject *resultobj = NULL;
4751 wxPoint *arg1 = (wxPoint *) 0 ;
4752 wxPoint *arg2 = 0 ;
4753 wxPoint result;
4754 wxPoint temp2 ;
4755 PyObject * obj0 = 0 ;
4756 PyObject * obj1 = 0 ;
4757 char *kwnames[] = {
4758 (char *) "self",(char *) "pt", NULL
4759 };
4760
4761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4763 if (SWIG_arg_fail(1)) SWIG_fail;
4764 {
4765 arg2 = &temp2;
4766 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4767 }
4768 {
4769 PyThreadState* __tstate = wxPyBeginAllowThreads();
4770 result = (arg1)->operator -((wxPoint const &)*arg2);
4771
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 {
4776 wxPoint * resultptr;
4777 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4778 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4779 }
4780 return resultobj;
4781 fail:
4782 return NULL;
4783 }
4784
4785
4786 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4787 PyObject *resultobj = NULL;
4788 wxPoint *arg1 = (wxPoint *) 0 ;
4789 wxPoint *arg2 = 0 ;
4790 wxPoint *result;
4791 wxPoint temp2 ;
4792 PyObject * obj0 = 0 ;
4793 PyObject * obj1 = 0 ;
4794 char *kwnames[] = {
4795 (char *) "self",(char *) "pt", NULL
4796 };
4797
4798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4800 if (SWIG_arg_fail(1)) SWIG_fail;
4801 {
4802 arg2 = &temp2;
4803 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4804 }
4805 {
4806 PyThreadState* __tstate = wxPyBeginAllowThreads();
4807 {
4808 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4809 result = (wxPoint *) &_result_ref;
4810 }
4811
4812 wxPyEndAllowThreads(__tstate);
4813 if (PyErr_Occurred()) SWIG_fail;
4814 }
4815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4816 return resultobj;
4817 fail:
4818 return NULL;
4819 }
4820
4821
4822 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4823 PyObject *resultobj = NULL;
4824 wxPoint *arg1 = (wxPoint *) 0 ;
4825 wxPoint *arg2 = 0 ;
4826 wxPoint *result;
4827 wxPoint temp2 ;
4828 PyObject * obj0 = 0 ;
4829 PyObject * obj1 = 0 ;
4830 char *kwnames[] = {
4831 (char *) "self",(char *) "pt", NULL
4832 };
4833
4834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4836 if (SWIG_arg_fail(1)) SWIG_fail;
4837 {
4838 arg2 = &temp2;
4839 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4840 }
4841 {
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 {
4844 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4845 result = (wxPoint *) &_result_ref;
4846 }
4847
4848 wxPyEndAllowThreads(__tstate);
4849 if (PyErr_Occurred()) SWIG_fail;
4850 }
4851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4852 return resultobj;
4853 fail:
4854 return NULL;
4855 }
4856
4857
4858 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4859 PyObject *resultobj = NULL;
4860 wxPoint *arg1 = (wxPoint *) 0 ;
4861 long arg2 ;
4862 long arg3 ;
4863 PyObject * obj0 = 0 ;
4864 PyObject * obj1 = 0 ;
4865 PyObject * obj2 = 0 ;
4866 char *kwnames[] = {
4867 (char *) "self",(char *) "x",(char *) "y", NULL
4868 };
4869
4870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4872 if (SWIG_arg_fail(1)) SWIG_fail;
4873 {
4874 arg2 = static_cast<long >(SWIG_As_long(obj1));
4875 if (SWIG_arg_fail(2)) SWIG_fail;
4876 }
4877 {
4878 arg3 = static_cast<long >(SWIG_As_long(obj2));
4879 if (SWIG_arg_fail(3)) SWIG_fail;
4880 }
4881 {
4882 PyThreadState* __tstate = wxPyBeginAllowThreads();
4883 wxPoint_Set(arg1,arg2,arg3);
4884
4885 wxPyEndAllowThreads(__tstate);
4886 if (PyErr_Occurred()) SWIG_fail;
4887 }
4888 Py_INCREF(Py_None); resultobj = Py_None;
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4896 PyObject *resultobj = NULL;
4897 wxPoint *arg1 = (wxPoint *) 0 ;
4898 PyObject *result;
4899 PyObject * obj0 = 0 ;
4900 char *kwnames[] = {
4901 (char *) "self", NULL
4902 };
4903
4904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4906 if (SWIG_arg_fail(1)) SWIG_fail;
4907 {
4908 PyThreadState* __tstate = wxPyBeginAllowThreads();
4909 result = (PyObject *)wxPoint_Get(arg1);
4910
4911 wxPyEndAllowThreads(__tstate);
4912 if (PyErr_Occurred()) SWIG_fail;
4913 }
4914 resultobj = result;
4915 return resultobj;
4916 fail:
4917 return NULL;
4918 }
4919
4920
4921 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4922 PyObject *obj;
4923 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4924 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4925 Py_INCREF(obj);
4926 return Py_BuildValue((char *)"");
4927 }
4928 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4929 PyObject *resultobj = NULL;
4930 int arg1 = (int) 0 ;
4931 int arg2 = (int) 0 ;
4932 int arg3 = (int) 0 ;
4933 int arg4 = (int) 0 ;
4934 wxRect *result;
4935 PyObject * obj0 = 0 ;
4936 PyObject * obj1 = 0 ;
4937 PyObject * obj2 = 0 ;
4938 PyObject * obj3 = 0 ;
4939 char *kwnames[] = {
4940 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4941 };
4942
4943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4944 if (obj0) {
4945 {
4946 arg1 = static_cast<int >(SWIG_As_int(obj0));
4947 if (SWIG_arg_fail(1)) SWIG_fail;
4948 }
4949 }
4950 if (obj1) {
4951 {
4952 arg2 = static_cast<int >(SWIG_As_int(obj1));
4953 if (SWIG_arg_fail(2)) SWIG_fail;
4954 }
4955 }
4956 if (obj2) {
4957 {
4958 arg3 = static_cast<int >(SWIG_As_int(obj2));
4959 if (SWIG_arg_fail(3)) SWIG_fail;
4960 }
4961 }
4962 if (obj3) {
4963 {
4964 arg4 = static_cast<int >(SWIG_As_int(obj3));
4965 if (SWIG_arg_fail(4)) SWIG_fail;
4966 }
4967 }
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4971
4972 wxPyEndAllowThreads(__tstate);
4973 if (PyErr_Occurred()) SWIG_fail;
4974 }
4975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4976 return resultobj;
4977 fail:
4978 return NULL;
4979 }
4980
4981
4982 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4983 PyObject *resultobj = NULL;
4984 wxPoint *arg1 = 0 ;
4985 wxPoint *arg2 = 0 ;
4986 wxRect *result;
4987 wxPoint temp1 ;
4988 wxPoint temp2 ;
4989 PyObject * obj0 = 0 ;
4990 PyObject * obj1 = 0 ;
4991 char *kwnames[] = {
4992 (char *) "topLeft",(char *) "bottomRight", NULL
4993 };
4994
4995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4996 {
4997 arg1 = &temp1;
4998 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4999 }
5000 {
5001 arg2 = &temp2;
5002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5003 }
5004 {
5005 PyThreadState* __tstate = wxPyBeginAllowThreads();
5006 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
5007
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5012 return resultobj;
5013 fail:
5014 return NULL;
5015 }
5016
5017
5018 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
5019 PyObject *resultobj = NULL;
5020 wxPoint *arg1 = 0 ;
5021 wxSize *arg2 = 0 ;
5022 wxRect *result;
5023 wxPoint temp1 ;
5024 wxSize temp2 ;
5025 PyObject * obj0 = 0 ;
5026 PyObject * obj1 = 0 ;
5027 char *kwnames[] = {
5028 (char *) "pos",(char *) "size", NULL
5029 };
5030
5031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5032 {
5033 arg1 = &temp1;
5034 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5035 }
5036 {
5037 arg2 = &temp2;
5038 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5039 }
5040 {
5041 PyThreadState* __tstate = wxPyBeginAllowThreads();
5042 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5043
5044 wxPyEndAllowThreads(__tstate);
5045 if (PyErr_Occurred()) SWIG_fail;
5046 }
5047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5048 return resultobj;
5049 fail:
5050 return NULL;
5051 }
5052
5053
5054 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5055 PyObject *resultobj = NULL;
5056 wxSize *arg1 = 0 ;
5057 wxRect *result;
5058 wxSize temp1 ;
5059 PyObject * obj0 = 0 ;
5060 char *kwnames[] = {
5061 (char *) "size", NULL
5062 };
5063
5064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5065 {
5066 arg1 = &temp1;
5067 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5068 }
5069 {
5070 PyThreadState* __tstate = wxPyBeginAllowThreads();
5071 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5072
5073 wxPyEndAllowThreads(__tstate);
5074 if (PyErr_Occurred()) SWIG_fail;
5075 }
5076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5077 return resultobj;
5078 fail:
5079 return NULL;
5080 }
5081
5082
5083 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5084 PyObject *resultobj = NULL;
5085 wxRect *arg1 = (wxRect *) 0 ;
5086 PyObject * obj0 = 0 ;
5087 char *kwnames[] = {
5088 (char *) "self", NULL
5089 };
5090
5091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5093 if (SWIG_arg_fail(1)) SWIG_fail;
5094 {
5095 PyThreadState* __tstate = wxPyBeginAllowThreads();
5096 delete arg1;
5097
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 Py_INCREF(Py_None); resultobj = Py_None;
5102 return resultobj;
5103 fail:
5104 return NULL;
5105 }
5106
5107
5108 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5109 PyObject *resultobj = NULL;
5110 wxRect *arg1 = (wxRect *) 0 ;
5111 int result;
5112 PyObject * obj0 = 0 ;
5113 char *kwnames[] = {
5114 (char *) "self", NULL
5115 };
5116
5117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5119 if (SWIG_arg_fail(1)) SWIG_fail;
5120 {
5121 PyThreadState* __tstate = wxPyBeginAllowThreads();
5122 result = (int)((wxRect const *)arg1)->GetX();
5123
5124 wxPyEndAllowThreads(__tstate);
5125 if (PyErr_Occurred()) SWIG_fail;
5126 }
5127 {
5128 resultobj = SWIG_From_int(static_cast<int >(result));
5129 }
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5137 PyObject *resultobj = NULL;
5138 wxRect *arg1 = (wxRect *) 0 ;
5139 int arg2 ;
5140 PyObject * obj0 = 0 ;
5141 PyObject * obj1 = 0 ;
5142 char *kwnames[] = {
5143 (char *) "self",(char *) "x", NULL
5144 };
5145
5146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5148 if (SWIG_arg_fail(1)) SWIG_fail;
5149 {
5150 arg2 = static_cast<int >(SWIG_As_int(obj1));
5151 if (SWIG_arg_fail(2)) SWIG_fail;
5152 }
5153 {
5154 PyThreadState* __tstate = wxPyBeginAllowThreads();
5155 (arg1)->SetX(arg2);
5156
5157 wxPyEndAllowThreads(__tstate);
5158 if (PyErr_Occurred()) SWIG_fail;
5159 }
5160 Py_INCREF(Py_None); resultobj = Py_None;
5161 return resultobj;
5162 fail:
5163 return NULL;
5164 }
5165
5166
5167 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5168 PyObject *resultobj = NULL;
5169 wxRect *arg1 = (wxRect *) 0 ;
5170 int result;
5171 PyObject * obj0 = 0 ;
5172 char *kwnames[] = {
5173 (char *) "self", NULL
5174 };
5175
5176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5178 if (SWIG_arg_fail(1)) SWIG_fail;
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 result = (int)(arg1)->GetY();
5182
5183 wxPyEndAllowThreads(__tstate);
5184 if (PyErr_Occurred()) SWIG_fail;
5185 }
5186 {
5187 resultobj = SWIG_From_int(static_cast<int >(result));
5188 }
5189 return resultobj;
5190 fail:
5191 return NULL;
5192 }
5193
5194
5195 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5196 PyObject *resultobj = NULL;
5197 wxRect *arg1 = (wxRect *) 0 ;
5198 int arg2 ;
5199 PyObject * obj0 = 0 ;
5200 PyObject * obj1 = 0 ;
5201 char *kwnames[] = {
5202 (char *) "self",(char *) "y", NULL
5203 };
5204
5205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5207 if (SWIG_arg_fail(1)) SWIG_fail;
5208 {
5209 arg2 = static_cast<int >(SWIG_As_int(obj1));
5210 if (SWIG_arg_fail(2)) SWIG_fail;
5211 }
5212 {
5213 PyThreadState* __tstate = wxPyBeginAllowThreads();
5214 (arg1)->SetY(arg2);
5215
5216 wxPyEndAllowThreads(__tstate);
5217 if (PyErr_Occurred()) SWIG_fail;
5218 }
5219 Py_INCREF(Py_None); resultobj = Py_None;
5220 return resultobj;
5221 fail:
5222 return NULL;
5223 }
5224
5225
5226 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5227 PyObject *resultobj = NULL;
5228 wxRect *arg1 = (wxRect *) 0 ;
5229 int result;
5230 PyObject * obj0 = 0 ;
5231 char *kwnames[] = {
5232 (char *) "self", NULL
5233 };
5234
5235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5237 if (SWIG_arg_fail(1)) SWIG_fail;
5238 {
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 result = (int)((wxRect const *)arg1)->GetWidth();
5241
5242 wxPyEndAllowThreads(__tstate);
5243 if (PyErr_Occurred()) SWIG_fail;
5244 }
5245 {
5246 resultobj = SWIG_From_int(static_cast<int >(result));
5247 }
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj = NULL;
5256 wxRect *arg1 = (wxRect *) 0 ;
5257 int arg2 ;
5258 PyObject * obj0 = 0 ;
5259 PyObject * obj1 = 0 ;
5260 char *kwnames[] = {
5261 (char *) "self",(char *) "w", NULL
5262 };
5263
5264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5266 if (SWIG_arg_fail(1)) SWIG_fail;
5267 {
5268 arg2 = static_cast<int >(SWIG_As_int(obj1));
5269 if (SWIG_arg_fail(2)) SWIG_fail;
5270 }
5271 {
5272 PyThreadState* __tstate = wxPyBeginAllowThreads();
5273 (arg1)->SetWidth(arg2);
5274
5275 wxPyEndAllowThreads(__tstate);
5276 if (PyErr_Occurred()) SWIG_fail;
5277 }
5278 Py_INCREF(Py_None); resultobj = Py_None;
5279 return resultobj;
5280 fail:
5281 return NULL;
5282 }
5283
5284
5285 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5286 PyObject *resultobj = NULL;
5287 wxRect *arg1 = (wxRect *) 0 ;
5288 int result;
5289 PyObject * obj0 = 0 ;
5290 char *kwnames[] = {
5291 (char *) "self", NULL
5292 };
5293
5294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5296 if (SWIG_arg_fail(1)) SWIG_fail;
5297 {
5298 PyThreadState* __tstate = wxPyBeginAllowThreads();
5299 result = (int)((wxRect const *)arg1)->GetHeight();
5300
5301 wxPyEndAllowThreads(__tstate);
5302 if (PyErr_Occurred()) SWIG_fail;
5303 }
5304 {
5305 resultobj = SWIG_From_int(static_cast<int >(result));
5306 }
5307 return resultobj;
5308 fail:
5309 return NULL;
5310 }
5311
5312
5313 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5314 PyObject *resultobj = NULL;
5315 wxRect *arg1 = (wxRect *) 0 ;
5316 int arg2 ;
5317 PyObject * obj0 = 0 ;
5318 PyObject * obj1 = 0 ;
5319 char *kwnames[] = {
5320 (char *) "self",(char *) "h", NULL
5321 };
5322
5323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5325 if (SWIG_arg_fail(1)) SWIG_fail;
5326 {
5327 arg2 = static_cast<int >(SWIG_As_int(obj1));
5328 if (SWIG_arg_fail(2)) SWIG_fail;
5329 }
5330 {
5331 PyThreadState* __tstate = wxPyBeginAllowThreads();
5332 (arg1)->SetHeight(arg2);
5333
5334 wxPyEndAllowThreads(__tstate);
5335 if (PyErr_Occurred()) SWIG_fail;
5336 }
5337 Py_INCREF(Py_None); resultobj = Py_None;
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5345 PyObject *resultobj = NULL;
5346 wxRect *arg1 = (wxRect *) 0 ;
5347 wxPoint result;
5348 PyObject * obj0 = 0 ;
5349 char *kwnames[] = {
5350 (char *) "self", NULL
5351 };
5352
5353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5355 if (SWIG_arg_fail(1)) SWIG_fail;
5356 {
5357 PyThreadState* __tstate = wxPyBeginAllowThreads();
5358 result = ((wxRect const *)arg1)->GetPosition();
5359
5360 wxPyEndAllowThreads(__tstate);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 wxPoint * resultptr;
5365 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5367 }
5368 return resultobj;
5369 fail:
5370 return NULL;
5371 }
5372
5373
5374 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj = NULL;
5376 wxRect *arg1 = (wxRect *) 0 ;
5377 wxPoint *arg2 = 0 ;
5378 wxPoint temp2 ;
5379 PyObject * obj0 = 0 ;
5380 PyObject * obj1 = 0 ;
5381 char *kwnames[] = {
5382 (char *) "self",(char *) "p", NULL
5383 };
5384
5385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5387 if (SWIG_arg_fail(1)) SWIG_fail;
5388 {
5389 arg2 = &temp2;
5390 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5391 }
5392 {
5393 PyThreadState* __tstate = wxPyBeginAllowThreads();
5394 (arg1)->SetPosition((wxPoint const &)*arg2);
5395
5396 wxPyEndAllowThreads(__tstate);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 Py_INCREF(Py_None); resultobj = Py_None;
5400 return resultobj;
5401 fail:
5402 return NULL;
5403 }
5404
5405
5406 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj = NULL;
5408 wxRect *arg1 = (wxRect *) 0 ;
5409 wxSize result;
5410 PyObject * obj0 = 0 ;
5411 char *kwnames[] = {
5412 (char *) "self", NULL
5413 };
5414
5415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5417 if (SWIG_arg_fail(1)) SWIG_fail;
5418 {
5419 PyThreadState* __tstate = wxPyBeginAllowThreads();
5420 result = ((wxRect const *)arg1)->GetSize();
5421
5422 wxPyEndAllowThreads(__tstate);
5423 if (PyErr_Occurred()) SWIG_fail;
5424 }
5425 {
5426 wxSize * resultptr;
5427 resultptr = new wxSize(static_cast<wxSize & >(result));
5428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5429 }
5430 return resultobj;
5431 fail:
5432 return NULL;
5433 }
5434
5435
5436 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5437 PyObject *resultobj = NULL;
5438 wxRect *arg1 = (wxRect *) 0 ;
5439 wxSize *arg2 = 0 ;
5440 wxSize temp2 ;
5441 PyObject * obj0 = 0 ;
5442 PyObject * obj1 = 0 ;
5443 char *kwnames[] = {
5444 (char *) "self",(char *) "s", NULL
5445 };
5446
5447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5449 if (SWIG_arg_fail(1)) SWIG_fail;
5450 {
5451 arg2 = &temp2;
5452 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5453 }
5454 {
5455 PyThreadState* __tstate = wxPyBeginAllowThreads();
5456 (arg1)->SetSize((wxSize const &)*arg2);
5457
5458 wxPyEndAllowThreads(__tstate);
5459 if (PyErr_Occurred()) SWIG_fail;
5460 }
5461 Py_INCREF(Py_None); resultobj = Py_None;
5462 return resultobj;
5463 fail:
5464 return NULL;
5465 }
5466
5467
5468 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5469 PyObject *resultobj = NULL;
5470 wxRect *arg1 = (wxRect *) 0 ;
5471 bool result;
5472 PyObject * obj0 = 0 ;
5473 char *kwnames[] = {
5474 (char *) "self", NULL
5475 };
5476
5477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5479 if (SWIG_arg_fail(1)) SWIG_fail;
5480 {
5481 PyThreadState* __tstate = wxPyBeginAllowThreads();
5482 result = (bool)((wxRect const *)arg1)->IsEmpty();
5483
5484 wxPyEndAllowThreads(__tstate);
5485 if (PyErr_Occurred()) SWIG_fail;
5486 }
5487 {
5488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5489 }
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5497 PyObject *resultobj = NULL;
5498 wxRect *arg1 = (wxRect *) 0 ;
5499 wxPoint result;
5500 PyObject * obj0 = 0 ;
5501 char *kwnames[] = {
5502 (char *) "self", NULL
5503 };
5504
5505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5507 if (SWIG_arg_fail(1)) SWIG_fail;
5508 {
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 result = ((wxRect const *)arg1)->GetTopLeft();
5511
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 wxPoint * resultptr;
5517 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5518 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5519 }
5520 return resultobj;
5521 fail:
5522 return NULL;
5523 }
5524
5525
5526 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5527 PyObject *resultobj = NULL;
5528 wxRect *arg1 = (wxRect *) 0 ;
5529 wxPoint *arg2 = 0 ;
5530 wxPoint temp2 ;
5531 PyObject * obj0 = 0 ;
5532 PyObject * obj1 = 0 ;
5533 char *kwnames[] = {
5534 (char *) "self",(char *) "p", NULL
5535 };
5536
5537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5539 if (SWIG_arg_fail(1)) SWIG_fail;
5540 {
5541 arg2 = &temp2;
5542 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5543 }
5544 {
5545 PyThreadState* __tstate = wxPyBeginAllowThreads();
5546 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5547
5548 wxPyEndAllowThreads(__tstate);
5549 if (PyErr_Occurred()) SWIG_fail;
5550 }
5551 Py_INCREF(Py_None); resultobj = Py_None;
5552 return resultobj;
5553 fail:
5554 return NULL;
5555 }
5556
5557
5558 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5559 PyObject *resultobj = NULL;
5560 wxRect *arg1 = (wxRect *) 0 ;
5561 wxPoint result;
5562 PyObject * obj0 = 0 ;
5563 char *kwnames[] = {
5564 (char *) "self", NULL
5565 };
5566
5567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5569 if (SWIG_arg_fail(1)) SWIG_fail;
5570 {
5571 PyThreadState* __tstate = wxPyBeginAllowThreads();
5572 result = ((wxRect const *)arg1)->GetBottomRight();
5573
5574 wxPyEndAllowThreads(__tstate);
5575 if (PyErr_Occurred()) SWIG_fail;
5576 }
5577 {
5578 wxPoint * resultptr;
5579 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj = NULL;
5590 wxRect *arg1 = (wxRect *) 0 ;
5591 wxPoint *arg2 = 0 ;
5592 wxPoint temp2 ;
5593 PyObject * obj0 = 0 ;
5594 PyObject * obj1 = 0 ;
5595 char *kwnames[] = {
5596 (char *) "self",(char *) "p", NULL
5597 };
5598
5599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5601 if (SWIG_arg_fail(1)) SWIG_fail;
5602 {
5603 arg2 = &temp2;
5604 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5605 }
5606 {
5607 PyThreadState* __tstate = wxPyBeginAllowThreads();
5608 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5609
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 Py_INCREF(Py_None); resultobj = Py_None;
5614 return resultobj;
5615 fail:
5616 return NULL;
5617 }
5618
5619
5620 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5621 PyObject *resultobj = NULL;
5622 wxRect *arg1 = (wxRect *) 0 ;
5623 int result;
5624 PyObject * obj0 = 0 ;
5625 char *kwnames[] = {
5626 (char *) "self", NULL
5627 };
5628
5629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5631 if (SWIG_arg_fail(1)) SWIG_fail;
5632 {
5633 PyThreadState* __tstate = wxPyBeginAllowThreads();
5634 result = (int)((wxRect const *)arg1)->GetLeft();
5635
5636 wxPyEndAllowThreads(__tstate);
5637 if (PyErr_Occurred()) SWIG_fail;
5638 }
5639 {
5640 resultobj = SWIG_From_int(static_cast<int >(result));
5641 }
5642 return resultobj;
5643 fail:
5644 return NULL;
5645 }
5646
5647
5648 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5649 PyObject *resultobj = NULL;
5650 wxRect *arg1 = (wxRect *) 0 ;
5651 int result;
5652 PyObject * obj0 = 0 ;
5653 char *kwnames[] = {
5654 (char *) "self", NULL
5655 };
5656
5657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5659 if (SWIG_arg_fail(1)) SWIG_fail;
5660 {
5661 PyThreadState* __tstate = wxPyBeginAllowThreads();
5662 result = (int)((wxRect const *)arg1)->GetTop();
5663
5664 wxPyEndAllowThreads(__tstate);
5665 if (PyErr_Occurred()) SWIG_fail;
5666 }
5667 {
5668 resultobj = SWIG_From_int(static_cast<int >(result));
5669 }
5670 return resultobj;
5671 fail:
5672 return NULL;
5673 }
5674
5675
5676 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5677 PyObject *resultobj = NULL;
5678 wxRect *arg1 = (wxRect *) 0 ;
5679 int result;
5680 PyObject * obj0 = 0 ;
5681 char *kwnames[] = {
5682 (char *) "self", NULL
5683 };
5684
5685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5687 if (SWIG_arg_fail(1)) SWIG_fail;
5688 {
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 result = (int)((wxRect const *)arg1)->GetBottom();
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 {
5696 resultobj = SWIG_From_int(static_cast<int >(result));
5697 }
5698 return resultobj;
5699 fail:
5700 return NULL;
5701 }
5702
5703
5704 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5705 PyObject *resultobj = NULL;
5706 wxRect *arg1 = (wxRect *) 0 ;
5707 int result;
5708 PyObject * obj0 = 0 ;
5709 char *kwnames[] = {
5710 (char *) "self", NULL
5711 };
5712
5713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5715 if (SWIG_arg_fail(1)) SWIG_fail;
5716 {
5717 PyThreadState* __tstate = wxPyBeginAllowThreads();
5718 result = (int)((wxRect const *)arg1)->GetRight();
5719
5720 wxPyEndAllowThreads(__tstate);
5721 if (PyErr_Occurred()) SWIG_fail;
5722 }
5723 {
5724 resultobj = SWIG_From_int(static_cast<int >(result));
5725 }
5726 return resultobj;
5727 fail:
5728 return NULL;
5729 }
5730
5731
5732 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5733 PyObject *resultobj = NULL;
5734 wxRect *arg1 = (wxRect *) 0 ;
5735 int arg2 ;
5736 PyObject * obj0 = 0 ;
5737 PyObject * obj1 = 0 ;
5738 char *kwnames[] = {
5739 (char *) "self",(char *) "left", NULL
5740 };
5741
5742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5744 if (SWIG_arg_fail(1)) SWIG_fail;
5745 {
5746 arg2 = static_cast<int >(SWIG_As_int(obj1));
5747 if (SWIG_arg_fail(2)) SWIG_fail;
5748 }
5749 {
5750 PyThreadState* __tstate = wxPyBeginAllowThreads();
5751 (arg1)->SetLeft(arg2);
5752
5753 wxPyEndAllowThreads(__tstate);
5754 if (PyErr_Occurred()) SWIG_fail;
5755 }
5756 Py_INCREF(Py_None); resultobj = Py_None;
5757 return resultobj;
5758 fail:
5759 return NULL;
5760 }
5761
5762
5763 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5764 PyObject *resultobj = NULL;
5765 wxRect *arg1 = (wxRect *) 0 ;
5766 int arg2 ;
5767 PyObject * obj0 = 0 ;
5768 PyObject * obj1 = 0 ;
5769 char *kwnames[] = {
5770 (char *) "self",(char *) "right", NULL
5771 };
5772
5773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5775 if (SWIG_arg_fail(1)) SWIG_fail;
5776 {
5777 arg2 = static_cast<int >(SWIG_As_int(obj1));
5778 if (SWIG_arg_fail(2)) SWIG_fail;
5779 }
5780 {
5781 PyThreadState* __tstate = wxPyBeginAllowThreads();
5782 (arg1)->SetRight(arg2);
5783
5784 wxPyEndAllowThreads(__tstate);
5785 if (PyErr_Occurred()) SWIG_fail;
5786 }
5787 Py_INCREF(Py_None); resultobj = Py_None;
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj = NULL;
5796 wxRect *arg1 = (wxRect *) 0 ;
5797 int arg2 ;
5798 PyObject * obj0 = 0 ;
5799 PyObject * obj1 = 0 ;
5800 char *kwnames[] = {
5801 (char *) "self",(char *) "top", NULL
5802 };
5803
5804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5806 if (SWIG_arg_fail(1)) SWIG_fail;
5807 {
5808 arg2 = static_cast<int >(SWIG_As_int(obj1));
5809 if (SWIG_arg_fail(2)) SWIG_fail;
5810 }
5811 {
5812 PyThreadState* __tstate = wxPyBeginAllowThreads();
5813 (arg1)->SetTop(arg2);
5814
5815 wxPyEndAllowThreads(__tstate);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 Py_INCREF(Py_None); resultobj = Py_None;
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5826 PyObject *resultobj = NULL;
5827 wxRect *arg1 = (wxRect *) 0 ;
5828 int arg2 ;
5829 PyObject * obj0 = 0 ;
5830 PyObject * obj1 = 0 ;
5831 char *kwnames[] = {
5832 (char *) "self",(char *) "bottom", NULL
5833 };
5834
5835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5837 if (SWIG_arg_fail(1)) SWIG_fail;
5838 {
5839 arg2 = static_cast<int >(SWIG_As_int(obj1));
5840 if (SWIG_arg_fail(2)) SWIG_fail;
5841 }
5842 {
5843 PyThreadState* __tstate = wxPyBeginAllowThreads();
5844 (arg1)->SetBottom(arg2);
5845
5846 wxPyEndAllowThreads(__tstate);
5847 if (PyErr_Occurred()) SWIG_fail;
5848 }
5849 Py_INCREF(Py_None); resultobj = Py_None;
5850 return resultobj;
5851 fail:
5852 return NULL;
5853 }
5854
5855
5856 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5857 PyObject *resultobj = NULL;
5858 wxRect *arg1 = (wxRect *) 0 ;
5859 int arg2 ;
5860 int arg3 ;
5861 wxRect *result;
5862 PyObject * obj0 = 0 ;
5863 PyObject * obj1 = 0 ;
5864 PyObject * obj2 = 0 ;
5865 char *kwnames[] = {
5866 (char *) "self",(char *) "dx",(char *) "dy", NULL
5867 };
5868
5869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5871 if (SWIG_arg_fail(1)) SWIG_fail;
5872 {
5873 arg2 = static_cast<int >(SWIG_As_int(obj1));
5874 if (SWIG_arg_fail(2)) SWIG_fail;
5875 }
5876 {
5877 arg3 = static_cast<int >(SWIG_As_int(obj2));
5878 if (SWIG_arg_fail(3)) SWIG_fail;
5879 }
5880 {
5881 PyThreadState* __tstate = wxPyBeginAllowThreads();
5882 {
5883 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5884 result = (wxRect *) &_result_ref;
5885 }
5886
5887 wxPyEndAllowThreads(__tstate);
5888 if (PyErr_Occurred()) SWIG_fail;
5889 }
5890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5891 return resultobj;
5892 fail:
5893 return NULL;
5894 }
5895
5896
5897 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5898 PyObject *resultobj = NULL;
5899 wxRect *arg1 = (wxRect *) 0 ;
5900 int arg2 ;
5901 int arg3 ;
5902 wxRect *result;
5903 PyObject * obj0 = 0 ;
5904 PyObject * obj1 = 0 ;
5905 PyObject * obj2 = 0 ;
5906 char *kwnames[] = {
5907 (char *) "self",(char *) "dx",(char *) "dy", NULL
5908 };
5909
5910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5912 if (SWIG_arg_fail(1)) SWIG_fail;
5913 {
5914 arg2 = static_cast<int >(SWIG_As_int(obj1));
5915 if (SWIG_arg_fail(2)) SWIG_fail;
5916 }
5917 {
5918 arg3 = static_cast<int >(SWIG_As_int(obj2));
5919 if (SWIG_arg_fail(3)) SWIG_fail;
5920 }
5921 {
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 {
5924 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5925 result = (wxRect *) &_result_ref;
5926 }
5927
5928 wxPyEndAllowThreads(__tstate);
5929 if (PyErr_Occurred()) SWIG_fail;
5930 }
5931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5932 return resultobj;
5933 fail:
5934 return NULL;
5935 }
5936
5937
5938 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5939 PyObject *resultobj = NULL;
5940 wxRect *arg1 = (wxRect *) 0 ;
5941 int arg2 ;
5942 int arg3 ;
5943 PyObject * obj0 = 0 ;
5944 PyObject * obj1 = 0 ;
5945 PyObject * obj2 = 0 ;
5946 char *kwnames[] = {
5947 (char *) "self",(char *) "dx",(char *) "dy", NULL
5948 };
5949
5950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5952 if (SWIG_arg_fail(1)) SWIG_fail;
5953 {
5954 arg2 = static_cast<int >(SWIG_As_int(obj1));
5955 if (SWIG_arg_fail(2)) SWIG_fail;
5956 }
5957 {
5958 arg3 = static_cast<int >(SWIG_As_int(obj2));
5959 if (SWIG_arg_fail(3)) SWIG_fail;
5960 }
5961 {
5962 PyThreadState* __tstate = wxPyBeginAllowThreads();
5963 (arg1)->Offset(arg2,arg3);
5964
5965 wxPyEndAllowThreads(__tstate);
5966 if (PyErr_Occurred()) SWIG_fail;
5967 }
5968 Py_INCREF(Py_None); resultobj = Py_None;
5969 return resultobj;
5970 fail:
5971 return NULL;
5972 }
5973
5974
5975 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5976 PyObject *resultobj = NULL;
5977 wxRect *arg1 = (wxRect *) 0 ;
5978 wxPoint *arg2 = 0 ;
5979 wxPoint temp2 ;
5980 PyObject * obj0 = 0 ;
5981 PyObject * obj1 = 0 ;
5982 char *kwnames[] = {
5983 (char *) "self",(char *) "pt", NULL
5984 };
5985
5986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5988 if (SWIG_arg_fail(1)) SWIG_fail;
5989 {
5990 arg2 = &temp2;
5991 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5992 }
5993 {
5994 PyThreadState* __tstate = wxPyBeginAllowThreads();
5995 (arg1)->Offset((wxPoint const &)*arg2);
5996
5997 wxPyEndAllowThreads(__tstate);
5998 if (PyErr_Occurred()) SWIG_fail;
5999 }
6000 Py_INCREF(Py_None); resultobj = Py_None;
6001 return resultobj;
6002 fail:
6003 return NULL;
6004 }
6005
6006
6007 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6008 PyObject *resultobj = NULL;
6009 wxRect *arg1 = (wxRect *) 0 ;
6010 wxRect *arg2 = 0 ;
6011 wxRect result;
6012 wxRect temp2 ;
6013 PyObject * obj0 = 0 ;
6014 PyObject * obj1 = 0 ;
6015 char *kwnames[] = {
6016 (char *) "self",(char *) "rect", NULL
6017 };
6018
6019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
6020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6021 if (SWIG_arg_fail(1)) SWIG_fail;
6022 {
6023 arg2 = &temp2;
6024 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6025 }
6026 {
6027 PyThreadState* __tstate = wxPyBeginAllowThreads();
6028 result = (arg1)->Intersect((wxRect const &)*arg2);
6029
6030 wxPyEndAllowThreads(__tstate);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 wxRect * resultptr;
6035 resultptr = new wxRect(static_cast<wxRect & >(result));
6036 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6037 }
6038 return resultobj;
6039 fail:
6040 return NULL;
6041 }
6042
6043
6044 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6045 PyObject *resultobj = NULL;
6046 wxRect *arg1 = (wxRect *) 0 ;
6047 wxRect *arg2 = 0 ;
6048 wxRect result;
6049 wxRect temp2 ;
6050 PyObject * obj0 = 0 ;
6051 PyObject * obj1 = 0 ;
6052 char *kwnames[] = {
6053 (char *) "self",(char *) "rect", NULL
6054 };
6055
6056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6058 if (SWIG_arg_fail(1)) SWIG_fail;
6059 {
6060 arg2 = &temp2;
6061 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6062 }
6063 {
6064 PyThreadState* __tstate = wxPyBeginAllowThreads();
6065 result = (arg1)->Union((wxRect const &)*arg2);
6066
6067 wxPyEndAllowThreads(__tstate);
6068 if (PyErr_Occurred()) SWIG_fail;
6069 }
6070 {
6071 wxRect * resultptr;
6072 resultptr = new wxRect(static_cast<wxRect & >(result));
6073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6074 }
6075 return resultobj;
6076 fail:
6077 return NULL;
6078 }
6079
6080
6081 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6082 PyObject *resultobj = NULL;
6083 wxRect *arg1 = (wxRect *) 0 ;
6084 wxRect *arg2 = 0 ;
6085 wxRect result;
6086 wxRect temp2 ;
6087 PyObject * obj0 = 0 ;
6088 PyObject * obj1 = 0 ;
6089 char *kwnames[] = {
6090 (char *) "self",(char *) "rect", NULL
6091 };
6092
6093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6095 if (SWIG_arg_fail(1)) SWIG_fail;
6096 {
6097 arg2 = &temp2;
6098 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6099 }
6100 {
6101 PyThreadState* __tstate = wxPyBeginAllowThreads();
6102 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6103
6104 wxPyEndAllowThreads(__tstate);
6105 if (PyErr_Occurred()) SWIG_fail;
6106 }
6107 {
6108 wxRect * resultptr;
6109 resultptr = new wxRect(static_cast<wxRect & >(result));
6110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6111 }
6112 return resultobj;
6113 fail:
6114 return NULL;
6115 }
6116
6117
6118 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6119 PyObject *resultobj = NULL;
6120 wxRect *arg1 = (wxRect *) 0 ;
6121 wxRect *arg2 = 0 ;
6122 wxRect *result;
6123 wxRect temp2 ;
6124 PyObject * obj0 = 0 ;
6125 PyObject * obj1 = 0 ;
6126 char *kwnames[] = {
6127 (char *) "self",(char *) "rect", NULL
6128 };
6129
6130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6132 if (SWIG_arg_fail(1)) SWIG_fail;
6133 {
6134 arg2 = &temp2;
6135 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6136 }
6137 {
6138 PyThreadState* __tstate = wxPyBeginAllowThreads();
6139 {
6140 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6141 result = (wxRect *) &_result_ref;
6142 }
6143
6144 wxPyEndAllowThreads(__tstate);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6155 PyObject *resultobj = NULL;
6156 wxRect *arg1 = (wxRect *) 0 ;
6157 wxRect *arg2 = 0 ;
6158 bool result;
6159 wxRect temp2 ;
6160 PyObject * obj0 = 0 ;
6161 PyObject * obj1 = 0 ;
6162 char *kwnames[] = {
6163 (char *) "self",(char *) "rect", NULL
6164 };
6165
6166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6168 if (SWIG_arg_fail(1)) SWIG_fail;
6169 {
6170 arg2 = &temp2;
6171 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6172 }
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6176
6177 wxPyEndAllowThreads(__tstate);
6178 if (PyErr_Occurred()) SWIG_fail;
6179 }
6180 {
6181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6182 }
6183 return resultobj;
6184 fail:
6185 return NULL;
6186 }
6187
6188
6189 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6190 PyObject *resultobj = NULL;
6191 wxRect *arg1 = (wxRect *) 0 ;
6192 wxRect *arg2 = 0 ;
6193 bool result;
6194 wxRect temp2 ;
6195 PyObject * obj0 = 0 ;
6196 PyObject * obj1 = 0 ;
6197 char *kwnames[] = {
6198 (char *) "self",(char *) "rect", NULL
6199 };
6200
6201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6203 if (SWIG_arg_fail(1)) SWIG_fail;
6204 {
6205 arg2 = &temp2;
6206 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6211
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 {
6216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6217 }
6218 return resultobj;
6219 fail:
6220 return NULL;
6221 }
6222
6223
6224 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6225 PyObject *resultobj = NULL;
6226 wxRect *arg1 = (wxRect *) 0 ;
6227 int arg2 ;
6228 int arg3 ;
6229 bool result;
6230 PyObject * obj0 = 0 ;
6231 PyObject * obj1 = 0 ;
6232 PyObject * obj2 = 0 ;
6233 char *kwnames[] = {
6234 (char *) "self",(char *) "x",(char *) "y", NULL
6235 };
6236
6237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6239 if (SWIG_arg_fail(1)) SWIG_fail;
6240 {
6241 arg2 = static_cast<int >(SWIG_As_int(obj1));
6242 if (SWIG_arg_fail(2)) SWIG_fail;
6243 }
6244 {
6245 arg3 = static_cast<int >(SWIG_As_int(obj2));
6246 if (SWIG_arg_fail(3)) SWIG_fail;
6247 }
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6251
6252 wxPyEndAllowThreads(__tstate);
6253 if (PyErr_Occurred()) SWIG_fail;
6254 }
6255 {
6256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6257 }
6258 return resultobj;
6259 fail:
6260 return NULL;
6261 }
6262
6263
6264 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6265 PyObject *resultobj = NULL;
6266 wxRect *arg1 = (wxRect *) 0 ;
6267 wxPoint *arg2 = 0 ;
6268 bool result;
6269 wxPoint temp2 ;
6270 PyObject * obj0 = 0 ;
6271 PyObject * obj1 = 0 ;
6272 char *kwnames[] = {
6273 (char *) "self",(char *) "pt", NULL
6274 };
6275
6276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6278 if (SWIG_arg_fail(1)) SWIG_fail;
6279 {
6280 arg2 = &temp2;
6281 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6282 }
6283 {
6284 PyThreadState* __tstate = wxPyBeginAllowThreads();
6285 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6286
6287 wxPyEndAllowThreads(__tstate);
6288 if (PyErr_Occurred()) SWIG_fail;
6289 }
6290 {
6291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6292 }
6293 return resultobj;
6294 fail:
6295 return NULL;
6296 }
6297
6298
6299 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6300 PyObject *resultobj = NULL;
6301 wxRect *arg1 = (wxRect *) 0 ;
6302 wxRect *arg2 = 0 ;
6303 bool result;
6304 wxRect temp2 ;
6305 PyObject * obj0 = 0 ;
6306 PyObject * obj1 = 0 ;
6307 char *kwnames[] = {
6308 (char *) "self",(char *) "rect", NULL
6309 };
6310
6311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6313 if (SWIG_arg_fail(1)) SWIG_fail;
6314 {
6315 arg2 = &temp2;
6316 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6317 }
6318 {
6319 PyThreadState* __tstate = wxPyBeginAllowThreads();
6320 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6321
6322 wxPyEndAllowThreads(__tstate);
6323 if (PyErr_Occurred()) SWIG_fail;
6324 }
6325 {
6326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6327 }
6328 return resultobj;
6329 fail:
6330 return NULL;
6331 }
6332
6333
6334 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6335 PyObject *resultobj = NULL;
6336 wxRect *arg1 = (wxRect *) 0 ;
6337 int arg2 ;
6338 PyObject * obj0 = 0 ;
6339 PyObject * obj1 = 0 ;
6340 char *kwnames[] = {
6341 (char *) "self",(char *) "x", NULL
6342 };
6343
6344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6346 if (SWIG_arg_fail(1)) SWIG_fail;
6347 {
6348 arg2 = static_cast<int >(SWIG_As_int(obj1));
6349 if (SWIG_arg_fail(2)) SWIG_fail;
6350 }
6351 if (arg1) (arg1)->x = arg2;
6352
6353 Py_INCREF(Py_None); resultobj = Py_None;
6354 return resultobj;
6355 fail:
6356 return NULL;
6357 }
6358
6359
6360 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6361 PyObject *resultobj = NULL;
6362 wxRect *arg1 = (wxRect *) 0 ;
6363 int result;
6364 PyObject * obj0 = 0 ;
6365 char *kwnames[] = {
6366 (char *) "self", NULL
6367 };
6368
6369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6371 if (SWIG_arg_fail(1)) SWIG_fail;
6372 result = (int) ((arg1)->x);
6373
6374 {
6375 resultobj = SWIG_From_int(static_cast<int >(result));
6376 }
6377 return resultobj;
6378 fail:
6379 return NULL;
6380 }
6381
6382
6383 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6384 PyObject *resultobj = NULL;
6385 wxRect *arg1 = (wxRect *) 0 ;
6386 int arg2 ;
6387 PyObject * obj0 = 0 ;
6388 PyObject * obj1 = 0 ;
6389 char *kwnames[] = {
6390 (char *) "self",(char *) "y", NULL
6391 };
6392
6393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6395 if (SWIG_arg_fail(1)) SWIG_fail;
6396 {
6397 arg2 = static_cast<int >(SWIG_As_int(obj1));
6398 if (SWIG_arg_fail(2)) SWIG_fail;
6399 }
6400 if (arg1) (arg1)->y = arg2;
6401
6402 Py_INCREF(Py_None); resultobj = Py_None;
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = NULL;
6411 wxRect *arg1 = (wxRect *) 0 ;
6412 int result;
6413 PyObject * obj0 = 0 ;
6414 char *kwnames[] = {
6415 (char *) "self", NULL
6416 };
6417
6418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6420 if (SWIG_arg_fail(1)) SWIG_fail;
6421 result = (int) ((arg1)->y);
6422
6423 {
6424 resultobj = SWIG_From_int(static_cast<int >(result));
6425 }
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj = NULL;
6434 wxRect *arg1 = (wxRect *) 0 ;
6435 int arg2 ;
6436 PyObject * obj0 = 0 ;
6437 PyObject * obj1 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "self",(char *) "width", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 {
6446 arg2 = static_cast<int >(SWIG_As_int(obj1));
6447 if (SWIG_arg_fail(2)) SWIG_fail;
6448 }
6449 if (arg1) (arg1)->width = arg2;
6450
6451 Py_INCREF(Py_None); resultobj = Py_None;
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6459 PyObject *resultobj = NULL;
6460 wxRect *arg1 = (wxRect *) 0 ;
6461 int result;
6462 PyObject * obj0 = 0 ;
6463 char *kwnames[] = {
6464 (char *) "self", NULL
6465 };
6466
6467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6469 if (SWIG_arg_fail(1)) SWIG_fail;
6470 result = (int) ((arg1)->width);
6471
6472 {
6473 resultobj = SWIG_From_int(static_cast<int >(result));
6474 }
6475 return resultobj;
6476 fail:
6477 return NULL;
6478 }
6479
6480
6481 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6482 PyObject *resultobj = NULL;
6483 wxRect *arg1 = (wxRect *) 0 ;
6484 int arg2 ;
6485 PyObject * obj0 = 0 ;
6486 PyObject * obj1 = 0 ;
6487 char *kwnames[] = {
6488 (char *) "self",(char *) "height", NULL
6489 };
6490
6491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6493 if (SWIG_arg_fail(1)) SWIG_fail;
6494 {
6495 arg2 = static_cast<int >(SWIG_As_int(obj1));
6496 if (SWIG_arg_fail(2)) SWIG_fail;
6497 }
6498 if (arg1) (arg1)->height = arg2;
6499
6500 Py_INCREF(Py_None); resultobj = Py_None;
6501 return resultobj;
6502 fail:
6503 return NULL;
6504 }
6505
6506
6507 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6508 PyObject *resultobj = NULL;
6509 wxRect *arg1 = (wxRect *) 0 ;
6510 int result;
6511 PyObject * obj0 = 0 ;
6512 char *kwnames[] = {
6513 (char *) "self", NULL
6514 };
6515
6516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6518 if (SWIG_arg_fail(1)) SWIG_fail;
6519 result = (int) ((arg1)->height);
6520
6521 {
6522 resultobj = SWIG_From_int(static_cast<int >(result));
6523 }
6524 return resultobj;
6525 fail:
6526 return NULL;
6527 }
6528
6529
6530 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6531 PyObject *resultobj = NULL;
6532 wxRect *arg1 = (wxRect *) 0 ;
6533 int arg2 = (int) 0 ;
6534 int arg3 = (int) 0 ;
6535 int arg4 = (int) 0 ;
6536 int arg5 = (int) 0 ;
6537 PyObject * obj0 = 0 ;
6538 PyObject * obj1 = 0 ;
6539 PyObject * obj2 = 0 ;
6540 PyObject * obj3 = 0 ;
6541 PyObject * obj4 = 0 ;
6542 char *kwnames[] = {
6543 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6544 };
6545
6546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6548 if (SWIG_arg_fail(1)) SWIG_fail;
6549 if (obj1) {
6550 {
6551 arg2 = static_cast<int >(SWIG_As_int(obj1));
6552 if (SWIG_arg_fail(2)) SWIG_fail;
6553 }
6554 }
6555 if (obj2) {
6556 {
6557 arg3 = static_cast<int >(SWIG_As_int(obj2));
6558 if (SWIG_arg_fail(3)) SWIG_fail;
6559 }
6560 }
6561 if (obj3) {
6562 {
6563 arg4 = static_cast<int >(SWIG_As_int(obj3));
6564 if (SWIG_arg_fail(4)) SWIG_fail;
6565 }
6566 }
6567 if (obj4) {
6568 {
6569 arg5 = static_cast<int >(SWIG_As_int(obj4));
6570 if (SWIG_arg_fail(5)) SWIG_fail;
6571 }
6572 }
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 Py_INCREF(Py_None); resultobj = Py_None;
6581 return resultobj;
6582 fail:
6583 return NULL;
6584 }
6585
6586
6587 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6588 PyObject *resultobj = NULL;
6589 wxRect *arg1 = (wxRect *) 0 ;
6590 PyObject *result;
6591 PyObject * obj0 = 0 ;
6592 char *kwnames[] = {
6593 (char *) "self", NULL
6594 };
6595
6596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6598 if (SWIG_arg_fail(1)) SWIG_fail;
6599 {
6600 PyThreadState* __tstate = wxPyBeginAllowThreads();
6601 result = (PyObject *)wxRect_Get(arg1);
6602
6603 wxPyEndAllowThreads(__tstate);
6604 if (PyErr_Occurred()) SWIG_fail;
6605 }
6606 resultobj = result;
6607 return resultobj;
6608 fail:
6609 return NULL;
6610 }
6611
6612
6613 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6614 PyObject *obj;
6615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6616 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6617 Py_INCREF(obj);
6618 return Py_BuildValue((char *)"");
6619 }
6620 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6621 PyObject *resultobj = NULL;
6622 wxRect *arg1 = (wxRect *) 0 ;
6623 wxRect *arg2 = (wxRect *) 0 ;
6624 PyObject *result;
6625 PyObject * obj0 = 0 ;
6626 PyObject * obj1 = 0 ;
6627 char *kwnames[] = {
6628 (char *) "r1",(char *) "r2", NULL
6629 };
6630
6631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6633 if (SWIG_arg_fail(1)) SWIG_fail;
6634 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6635 if (SWIG_arg_fail(2)) SWIG_fail;
6636 {
6637 if (!wxPyCheckForApp()) SWIG_fail;
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = (PyObject *)wxIntersectRect(arg1,arg2);
6640
6641 wxPyEndAllowThreads(__tstate);
6642 if (PyErr_Occurred()) SWIG_fail;
6643 }
6644 resultobj = result;
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6652 PyObject *resultobj = NULL;
6653 double arg1 = (double) 0.0 ;
6654 double arg2 = (double) 0.0 ;
6655 wxPoint2D *result;
6656 PyObject * obj0 = 0 ;
6657 PyObject * obj1 = 0 ;
6658 char *kwnames[] = {
6659 (char *) "x",(char *) "y", NULL
6660 };
6661
6662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6663 if (obj0) {
6664 {
6665 arg1 = static_cast<double >(SWIG_As_double(obj0));
6666 if (SWIG_arg_fail(1)) SWIG_fail;
6667 }
6668 }
6669 if (obj1) {
6670 {
6671 arg2 = static_cast<double >(SWIG_As_double(obj1));
6672 if (SWIG_arg_fail(2)) SWIG_fail;
6673 }
6674 }
6675 {
6676 PyThreadState* __tstate = wxPyBeginAllowThreads();
6677 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6678
6679 wxPyEndAllowThreads(__tstate);
6680 if (PyErr_Occurred()) SWIG_fail;
6681 }
6682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6683 return resultobj;
6684 fail:
6685 return NULL;
6686 }
6687
6688
6689 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6690 PyObject *resultobj = NULL;
6691 wxPoint2D *arg1 = 0 ;
6692 wxPoint2D *result;
6693 wxPoint2D temp1 ;
6694 PyObject * obj0 = 0 ;
6695 char *kwnames[] = {
6696 (char *) "pt", NULL
6697 };
6698
6699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6700 {
6701 arg1 = &temp1;
6702 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6703 }
6704 {
6705 PyThreadState* __tstate = wxPyBeginAllowThreads();
6706 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6707
6708 wxPyEndAllowThreads(__tstate);
6709 if (PyErr_Occurred()) SWIG_fail;
6710 }
6711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6712 return resultobj;
6713 fail:
6714 return NULL;
6715 }
6716
6717
6718 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6719 PyObject *resultobj = NULL;
6720 wxPoint *arg1 = 0 ;
6721 wxPoint2D *result;
6722 wxPoint temp1 ;
6723 PyObject * obj0 = 0 ;
6724 char *kwnames[] = {
6725 (char *) "pt", NULL
6726 };
6727
6728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6729 {
6730 arg1 = &temp1;
6731 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6732 }
6733 {
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6736
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6748 PyObject *resultobj = NULL;
6749 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6750 int *arg2 = (int *) 0 ;
6751 int *arg3 = (int *) 0 ;
6752 int temp2 ;
6753 int res2 = 0 ;
6754 int temp3 ;
6755 int res3 = 0 ;
6756 PyObject * obj0 = 0 ;
6757 char *kwnames[] = {
6758 (char *) "self", NULL
6759 };
6760
6761 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6762 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6765 if (SWIG_arg_fail(1)) SWIG_fail;
6766 {
6767 PyThreadState* __tstate = wxPyBeginAllowThreads();
6768 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6769
6770 wxPyEndAllowThreads(__tstate);
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 Py_INCREF(Py_None); resultobj = Py_None;
6774 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6775 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6776 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6777 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6785 PyObject *resultobj = NULL;
6786 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6787 int *arg2 = (int *) 0 ;
6788 int *arg3 = (int *) 0 ;
6789 int temp2 ;
6790 int res2 = 0 ;
6791 int temp3 ;
6792 int res3 = 0 ;
6793 PyObject * obj0 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self", NULL
6796 };
6797
6798 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6799 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6802 if (SWIG_arg_fail(1)) SWIG_fail;
6803 {
6804 PyThreadState* __tstate = wxPyBeginAllowThreads();
6805 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6806
6807 wxPyEndAllowThreads(__tstate);
6808 if (PyErr_Occurred()) SWIG_fail;
6809 }
6810 Py_INCREF(Py_None); resultobj = Py_None;
6811 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6812 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6813 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6814 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6815 return resultobj;
6816 fail:
6817 return NULL;
6818 }
6819
6820
6821 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6822 PyObject *resultobj = NULL;
6823 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6824 double result;
6825 PyObject * obj0 = 0 ;
6826 char *kwnames[] = {
6827 (char *) "self", NULL
6828 };
6829
6830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6832 if (SWIG_arg_fail(1)) SWIG_fail;
6833 {
6834 PyThreadState* __tstate = wxPyBeginAllowThreads();
6835 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6836
6837 wxPyEndAllowThreads(__tstate);
6838 if (PyErr_Occurred()) SWIG_fail;
6839 }
6840 {
6841 resultobj = SWIG_From_double(static_cast<double >(result));
6842 }
6843 return resultobj;
6844 fail:
6845 return NULL;
6846 }
6847
6848
6849 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6850 PyObject *resultobj = NULL;
6851 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6852 double result;
6853 PyObject * obj0 = 0 ;
6854 char *kwnames[] = {
6855 (char *) "self", NULL
6856 };
6857
6858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6860 if (SWIG_arg_fail(1)) SWIG_fail;
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6864
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 {
6869 resultobj = SWIG_From_double(static_cast<double >(result));
6870 }
6871 return resultobj;
6872 fail:
6873 return NULL;
6874 }
6875
6876
6877 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6878 PyObject *resultobj = NULL;
6879 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6880 double arg2 ;
6881 PyObject * obj0 = 0 ;
6882 PyObject * obj1 = 0 ;
6883 char *kwnames[] = {
6884 (char *) "self",(char *) "length", NULL
6885 };
6886
6887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6889 if (SWIG_arg_fail(1)) SWIG_fail;
6890 {
6891 arg2 = static_cast<double >(SWIG_As_double(obj1));
6892 if (SWIG_arg_fail(2)) SWIG_fail;
6893 }
6894 {
6895 PyThreadState* __tstate = wxPyBeginAllowThreads();
6896 (arg1)->SetVectorLength(arg2);
6897
6898 wxPyEndAllowThreads(__tstate);
6899 if (PyErr_Occurred()) SWIG_fail;
6900 }
6901 Py_INCREF(Py_None); resultobj = Py_None;
6902 return resultobj;
6903 fail:
6904 return NULL;
6905 }
6906
6907
6908 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6909 PyObject *resultobj = NULL;
6910 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6911 double arg2 ;
6912 PyObject * obj0 = 0 ;
6913 PyObject * obj1 = 0 ;
6914 char *kwnames[] = {
6915 (char *) "self",(char *) "degrees", NULL
6916 };
6917
6918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6920 if (SWIG_arg_fail(1)) SWIG_fail;
6921 {
6922 arg2 = static_cast<double >(SWIG_As_double(obj1));
6923 if (SWIG_arg_fail(2)) SWIG_fail;
6924 }
6925 {
6926 PyThreadState* __tstate = wxPyBeginAllowThreads();
6927 (arg1)->SetVectorAngle(arg2);
6928
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 Py_INCREF(Py_None); resultobj = Py_None;
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj = NULL;
6941 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6942 wxPoint2D *arg2 = 0 ;
6943 double result;
6944 wxPoint2D temp2 ;
6945 PyObject * obj0 = 0 ;
6946 PyObject * obj1 = 0 ;
6947 char *kwnames[] = {
6948 (char *) "self",(char *) "pt", NULL
6949 };
6950
6951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6953 if (SWIG_arg_fail(1)) SWIG_fail;
6954 {
6955 arg2 = &temp2;
6956 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6957 }
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6961
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 {
6966 resultobj = SWIG_From_double(static_cast<double >(result));
6967 }
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj = NULL;
6976 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6977 wxPoint2D *arg2 = 0 ;
6978 double result;
6979 wxPoint2D temp2 ;
6980 PyObject * obj0 = 0 ;
6981 PyObject * obj1 = 0 ;
6982 char *kwnames[] = {
6983 (char *) "self",(char *) "pt", NULL
6984 };
6985
6986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6988 if (SWIG_arg_fail(1)) SWIG_fail;
6989 {
6990 arg2 = &temp2;
6991 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6992 }
6993 {
6994 PyThreadState* __tstate = wxPyBeginAllowThreads();
6995 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6996
6997 wxPyEndAllowThreads(__tstate);
6998 if (PyErr_Occurred()) SWIG_fail;
6999 }
7000 {
7001 resultobj = SWIG_From_double(static_cast<double >(result));
7002 }
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7010 PyObject *resultobj = NULL;
7011 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7012 wxPoint2D *arg2 = 0 ;
7013 double result;
7014 wxPoint2D temp2 ;
7015 PyObject * obj0 = 0 ;
7016 PyObject * obj1 = 0 ;
7017 char *kwnames[] = {
7018 (char *) "self",(char *) "vec", NULL
7019 };
7020
7021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
7022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7023 if (SWIG_arg_fail(1)) SWIG_fail;
7024 {
7025 arg2 = &temp2;
7026 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7027 }
7028 {
7029 PyThreadState* __tstate = wxPyBeginAllowThreads();
7030 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7031
7032 wxPyEndAllowThreads(__tstate);
7033 if (PyErr_Occurred()) SWIG_fail;
7034 }
7035 {
7036 resultobj = SWIG_From_double(static_cast<double >(result));
7037 }
7038 return resultobj;
7039 fail:
7040 return NULL;
7041 }
7042
7043
7044 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7045 PyObject *resultobj = NULL;
7046 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7047 wxPoint2D *arg2 = 0 ;
7048 double result;
7049 wxPoint2D temp2 ;
7050 PyObject * obj0 = 0 ;
7051 PyObject * obj1 = 0 ;
7052 char *kwnames[] = {
7053 (char *) "self",(char *) "vec", NULL
7054 };
7055
7056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7058 if (SWIG_arg_fail(1)) SWIG_fail;
7059 {
7060 arg2 = &temp2;
7061 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7062 }
7063 {
7064 PyThreadState* __tstate = wxPyBeginAllowThreads();
7065 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7066
7067 wxPyEndAllowThreads(__tstate);
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 {
7071 resultobj = SWIG_From_double(static_cast<double >(result));
7072 }
7073 return resultobj;
7074 fail:
7075 return NULL;
7076 }
7077
7078
7079 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7080 PyObject *resultobj = NULL;
7081 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7082 wxPoint2D result;
7083 PyObject * obj0 = 0 ;
7084 char *kwnames[] = {
7085 (char *) "self", NULL
7086 };
7087
7088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 result = (arg1)->operator -();
7094
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 {
7099 wxPoint2D * resultptr;
7100 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7102 }
7103 return resultobj;
7104 fail:
7105 return NULL;
7106 }
7107
7108
7109 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7110 PyObject *resultobj = NULL;
7111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7112 wxPoint2D *arg2 = 0 ;
7113 wxPoint2D *result;
7114 wxPoint2D temp2 ;
7115 PyObject * obj0 = 0 ;
7116 PyObject * obj1 = 0 ;
7117 char *kwnames[] = {
7118 (char *) "self",(char *) "pt", NULL
7119 };
7120
7121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7123 if (SWIG_arg_fail(1)) SWIG_fail;
7124 {
7125 arg2 = &temp2;
7126 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7127 }
7128 {
7129 PyThreadState* __tstate = wxPyBeginAllowThreads();
7130 {
7131 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7132 result = (wxPoint2D *) &_result_ref;
7133 }
7134
7135 wxPyEndAllowThreads(__tstate);
7136 if (PyErr_Occurred()) SWIG_fail;
7137 }
7138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7139 return resultobj;
7140 fail:
7141 return NULL;
7142 }
7143
7144
7145 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7146 PyObject *resultobj = NULL;
7147 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7148 wxPoint2D *arg2 = 0 ;
7149 wxPoint2D *result;
7150 wxPoint2D temp2 ;
7151 PyObject * obj0 = 0 ;
7152 PyObject * obj1 = 0 ;
7153 char *kwnames[] = {
7154 (char *) "self",(char *) "pt", NULL
7155 };
7156
7157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7159 if (SWIG_arg_fail(1)) SWIG_fail;
7160 {
7161 arg2 = &temp2;
7162 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7163 }
7164 {
7165 PyThreadState* __tstate = wxPyBeginAllowThreads();
7166 {
7167 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7168 result = (wxPoint2D *) &_result_ref;
7169 }
7170
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7182 PyObject *resultobj = NULL;
7183 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7184 wxPoint2D *arg2 = 0 ;
7185 wxPoint2D *result;
7186 wxPoint2D temp2 ;
7187 PyObject * obj0 = 0 ;
7188 PyObject * obj1 = 0 ;
7189 char *kwnames[] = {
7190 (char *) "self",(char *) "pt", NULL
7191 };
7192
7193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7195 if (SWIG_arg_fail(1)) SWIG_fail;
7196 {
7197 arg2 = &temp2;
7198 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7199 }
7200 {
7201 PyThreadState* __tstate = wxPyBeginAllowThreads();
7202 {
7203 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7204 result = (wxPoint2D *) &_result_ref;
7205 }
7206
7207 wxPyEndAllowThreads(__tstate);
7208 if (PyErr_Occurred()) SWIG_fail;
7209 }
7210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7211 return resultobj;
7212 fail:
7213 return NULL;
7214 }
7215
7216
7217 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7218 PyObject *resultobj = NULL;
7219 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7220 wxPoint2D *arg2 = 0 ;
7221 wxPoint2D *result;
7222 wxPoint2D temp2 ;
7223 PyObject * obj0 = 0 ;
7224 PyObject * obj1 = 0 ;
7225 char *kwnames[] = {
7226 (char *) "self",(char *) "pt", NULL
7227 };
7228
7229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7231 if (SWIG_arg_fail(1)) SWIG_fail;
7232 {
7233 arg2 = &temp2;
7234 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7235 }
7236 {
7237 PyThreadState* __tstate = wxPyBeginAllowThreads();
7238 {
7239 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7240 result = (wxPoint2D *) &_result_ref;
7241 }
7242
7243 wxPyEndAllowThreads(__tstate);
7244 if (PyErr_Occurred()) SWIG_fail;
7245 }
7246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7247 return resultobj;
7248 fail:
7249 return NULL;
7250 }
7251
7252
7253 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7254 PyObject *resultobj = NULL;
7255 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7256 wxPoint2D *arg2 = 0 ;
7257 bool result;
7258 wxPoint2D temp2 ;
7259 PyObject * obj0 = 0 ;
7260 PyObject * obj1 = 0 ;
7261 char *kwnames[] = {
7262 (char *) "self",(char *) "pt", NULL
7263 };
7264
7265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7267 if (SWIG_arg_fail(1)) SWIG_fail;
7268 {
7269 arg2 = &temp2;
7270 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7271 }
7272 {
7273 PyThreadState* __tstate = wxPyBeginAllowThreads();
7274 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7275
7276 wxPyEndAllowThreads(__tstate);
7277 if (PyErr_Occurred()) SWIG_fail;
7278 }
7279 {
7280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7281 }
7282 return resultobj;
7283 fail:
7284 return NULL;
7285 }
7286
7287
7288 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7289 PyObject *resultobj = NULL;
7290 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7291 wxPoint2D *arg2 = 0 ;
7292 bool result;
7293 wxPoint2D temp2 ;
7294 PyObject * obj0 = 0 ;
7295 PyObject * obj1 = 0 ;
7296 char *kwnames[] = {
7297 (char *) "self",(char *) "pt", NULL
7298 };
7299
7300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7302 if (SWIG_arg_fail(1)) SWIG_fail;
7303 {
7304 arg2 = &temp2;
7305 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7306 }
7307 {
7308 PyThreadState* __tstate = wxPyBeginAllowThreads();
7309 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7310
7311 wxPyEndAllowThreads(__tstate);
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 {
7315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7316 }
7317 return resultobj;
7318 fail:
7319 return NULL;
7320 }
7321
7322
7323 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7324 PyObject *resultobj = NULL;
7325 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7326 double arg2 ;
7327 PyObject * obj0 = 0 ;
7328 PyObject * obj1 = 0 ;
7329 char *kwnames[] = {
7330 (char *) "self",(char *) "m_x", NULL
7331 };
7332
7333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7335 if (SWIG_arg_fail(1)) SWIG_fail;
7336 {
7337 arg2 = static_cast<double >(SWIG_As_double(obj1));
7338 if (SWIG_arg_fail(2)) SWIG_fail;
7339 }
7340 if (arg1) (arg1)->m_x = arg2;
7341
7342 Py_INCREF(Py_None); resultobj = Py_None;
7343 return resultobj;
7344 fail:
7345 return NULL;
7346 }
7347
7348
7349 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7350 PyObject *resultobj = NULL;
7351 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7352 double result;
7353 PyObject * obj0 = 0 ;
7354 char *kwnames[] = {
7355 (char *) "self", NULL
7356 };
7357
7358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7360 if (SWIG_arg_fail(1)) SWIG_fail;
7361 result = (double) ((arg1)->m_x);
7362
7363 {
7364 resultobj = SWIG_From_double(static_cast<double >(result));
7365 }
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj = NULL;
7374 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7375 double arg2 ;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 char *kwnames[] = {
7379 (char *) "self",(char *) "m_y", NULL
7380 };
7381
7382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7384 if (SWIG_arg_fail(1)) SWIG_fail;
7385 {
7386 arg2 = static_cast<double >(SWIG_As_double(obj1));
7387 if (SWIG_arg_fail(2)) SWIG_fail;
7388 }
7389 if (arg1) (arg1)->m_y = arg2;
7390
7391 Py_INCREF(Py_None); resultobj = Py_None;
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7399 PyObject *resultobj = NULL;
7400 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7401 double result;
7402 PyObject * obj0 = 0 ;
7403 char *kwnames[] = {
7404 (char *) "self", NULL
7405 };
7406
7407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7409 if (SWIG_arg_fail(1)) SWIG_fail;
7410 result = (double) ((arg1)->m_y);
7411
7412 {
7413 resultobj = SWIG_From_double(static_cast<double >(result));
7414 }
7415 return resultobj;
7416 fail:
7417 return NULL;
7418 }
7419
7420
7421 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7422 PyObject *resultobj = NULL;
7423 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7424 double arg2 = (double) 0 ;
7425 double arg3 = (double) 0 ;
7426 PyObject * obj0 = 0 ;
7427 PyObject * obj1 = 0 ;
7428 PyObject * obj2 = 0 ;
7429 char *kwnames[] = {
7430 (char *) "self",(char *) "x",(char *) "y", NULL
7431 };
7432
7433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7435 if (SWIG_arg_fail(1)) SWIG_fail;
7436 if (obj1) {
7437 {
7438 arg2 = static_cast<double >(SWIG_As_double(obj1));
7439 if (SWIG_arg_fail(2)) SWIG_fail;
7440 }
7441 }
7442 if (obj2) {
7443 {
7444 arg3 = static_cast<double >(SWIG_As_double(obj2));
7445 if (SWIG_arg_fail(3)) SWIG_fail;
7446 }
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 wxPoint2D_Set(arg1,arg2,arg3);
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 Py_INCREF(Py_None); resultobj = Py_None;
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj = NULL;
7464 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7465 PyObject *result;
7466 PyObject * obj0 = 0 ;
7467 char *kwnames[] = {
7468 (char *) "self", NULL
7469 };
7470
7471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7473 if (SWIG_arg_fail(1)) SWIG_fail;
7474 {
7475 PyThreadState* __tstate = wxPyBeginAllowThreads();
7476 result = (PyObject *)wxPoint2D_Get(arg1);
7477
7478 wxPyEndAllowThreads(__tstate);
7479 if (PyErr_Occurred()) SWIG_fail;
7480 }
7481 resultobj = result;
7482 return resultobj;
7483 fail:
7484 return NULL;
7485 }
7486
7487
7488 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7489 PyObject *obj;
7490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7491 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7492 Py_INCREF(obj);
7493 return Py_BuildValue((char *)"");
7494 }
7495 static int _wrap_DefaultPosition_set(PyObject *) {
7496 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7497 return 1;
7498 }
7499
7500
7501 static PyObject *_wrap_DefaultPosition_get(void) {
7502 PyObject *pyobj = NULL;
7503
7504 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7505 return pyobj;
7506 }
7507
7508
7509 static int _wrap_DefaultSize_set(PyObject *) {
7510 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7511 return 1;
7512 }
7513
7514
7515 static PyObject *_wrap_DefaultSize_get(void) {
7516 PyObject *pyobj = NULL;
7517
7518 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7519 return pyobj;
7520 }
7521
7522
7523 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7524 PyObject *resultobj = NULL;
7525 PyObject *arg1 = (PyObject *) 0 ;
7526 wxPyInputStream *result;
7527 PyObject * obj0 = 0 ;
7528 char *kwnames[] = {
7529 (char *) "p", NULL
7530 };
7531
7532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7533 arg1 = obj0;
7534 {
7535 PyThreadState* __tstate = wxPyBeginAllowThreads();
7536 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7537
7538 wxPyEndAllowThreads(__tstate);
7539 if (PyErr_Occurred()) SWIG_fail;
7540 }
7541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7542 return resultobj;
7543 fail:
7544 return NULL;
7545 }
7546
7547
7548 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7549 PyObject *resultobj = NULL;
7550 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7551 PyObject * obj0 = 0 ;
7552 char *kwnames[] = {
7553 (char *) "self", NULL
7554 };
7555
7556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7558 if (SWIG_arg_fail(1)) SWIG_fail;
7559 {
7560 PyThreadState* __tstate = wxPyBeginAllowThreads();
7561 delete arg1;
7562
7563 wxPyEndAllowThreads(__tstate);
7564 if (PyErr_Occurred()) SWIG_fail;
7565 }
7566 Py_INCREF(Py_None); resultobj = Py_None;
7567 return resultobj;
7568 fail:
7569 return NULL;
7570 }
7571
7572
7573 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7574 PyObject *resultobj = NULL;
7575 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7576 PyObject * obj0 = 0 ;
7577 char *kwnames[] = {
7578 (char *) "self", NULL
7579 };
7580
7581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7583 if (SWIG_arg_fail(1)) SWIG_fail;
7584 {
7585 PyThreadState* __tstate = wxPyBeginAllowThreads();
7586 (arg1)->close();
7587
7588 wxPyEndAllowThreads(__tstate);
7589 if (PyErr_Occurred()) SWIG_fail;
7590 }
7591 Py_INCREF(Py_None); resultobj = Py_None;
7592 return resultobj;
7593 fail:
7594 return NULL;
7595 }
7596
7597
7598 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7599 PyObject *resultobj = NULL;
7600 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7601 PyObject * obj0 = 0 ;
7602 char *kwnames[] = {
7603 (char *) "self", NULL
7604 };
7605
7606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7608 if (SWIG_arg_fail(1)) SWIG_fail;
7609 {
7610 PyThreadState* __tstate = wxPyBeginAllowThreads();
7611 (arg1)->flush();
7612
7613 wxPyEndAllowThreads(__tstate);
7614 if (PyErr_Occurred()) SWIG_fail;
7615 }
7616 Py_INCREF(Py_None); resultobj = Py_None;
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7624 PyObject *resultobj = NULL;
7625 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7626 bool result;
7627 PyObject * obj0 = 0 ;
7628 char *kwnames[] = {
7629 (char *) "self", NULL
7630 };
7631
7632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7634 if (SWIG_arg_fail(1)) SWIG_fail;
7635 {
7636 PyThreadState* __tstate = wxPyBeginAllowThreads();
7637 result = (bool)(arg1)->eof();
7638
7639 wxPyEndAllowThreads(__tstate);
7640 if (PyErr_Occurred()) SWIG_fail;
7641 }
7642 {
7643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7644 }
7645 return resultobj;
7646 fail:
7647 return NULL;
7648 }
7649
7650
7651 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7652 PyObject *resultobj = NULL;
7653 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7654 int arg2 = (int) -1 ;
7655 PyObject *result;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 char *kwnames[] = {
7659 (char *) "self",(char *) "size", NULL
7660 };
7661
7662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7664 if (SWIG_arg_fail(1)) SWIG_fail;
7665 if (obj1) {
7666 {
7667 arg2 = static_cast<int >(SWIG_As_int(obj1));
7668 if (SWIG_arg_fail(2)) SWIG_fail;
7669 }
7670 }
7671 {
7672 PyThreadState* __tstate = wxPyBeginAllowThreads();
7673 result = (PyObject *)(arg1)->read(arg2);
7674
7675 wxPyEndAllowThreads(__tstate);
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 resultobj = result;
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7686 PyObject *resultobj = NULL;
7687 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7688 int arg2 = (int) -1 ;
7689 PyObject *result;
7690 PyObject * obj0 = 0 ;
7691 PyObject * obj1 = 0 ;
7692 char *kwnames[] = {
7693 (char *) "self",(char *) "size", NULL
7694 };
7695
7696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7698 if (SWIG_arg_fail(1)) SWIG_fail;
7699 if (obj1) {
7700 {
7701 arg2 = static_cast<int >(SWIG_As_int(obj1));
7702 if (SWIG_arg_fail(2)) SWIG_fail;
7703 }
7704 }
7705 {
7706 PyThreadState* __tstate = wxPyBeginAllowThreads();
7707 result = (PyObject *)(arg1)->readline(arg2);
7708
7709 wxPyEndAllowThreads(__tstate);
7710 if (PyErr_Occurred()) SWIG_fail;
7711 }
7712 resultobj = result;
7713 return resultobj;
7714 fail:
7715 return NULL;
7716 }
7717
7718
7719 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7720 PyObject *resultobj = NULL;
7721 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7722 int arg2 = (int) -1 ;
7723 PyObject *result;
7724 PyObject * obj0 = 0 ;
7725 PyObject * obj1 = 0 ;
7726 char *kwnames[] = {
7727 (char *) "self",(char *) "sizehint", NULL
7728 };
7729
7730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7732 if (SWIG_arg_fail(1)) SWIG_fail;
7733 if (obj1) {
7734 {
7735 arg2 = static_cast<int >(SWIG_As_int(obj1));
7736 if (SWIG_arg_fail(2)) SWIG_fail;
7737 }
7738 }
7739 {
7740 PyThreadState* __tstate = wxPyBeginAllowThreads();
7741 result = (PyObject *)(arg1)->readlines(arg2);
7742
7743 wxPyEndAllowThreads(__tstate);
7744 if (PyErr_Occurred()) SWIG_fail;
7745 }
7746 resultobj = result;
7747 return resultobj;
7748 fail:
7749 return NULL;
7750 }
7751
7752
7753 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7754 PyObject *resultobj = NULL;
7755 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7756 int arg2 ;
7757 int arg3 = (int) 0 ;
7758 PyObject * obj0 = 0 ;
7759 PyObject * obj1 = 0 ;
7760 PyObject * obj2 = 0 ;
7761 char *kwnames[] = {
7762 (char *) "self",(char *) "offset",(char *) "whence", NULL
7763 };
7764
7765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7767 if (SWIG_arg_fail(1)) SWIG_fail;
7768 {
7769 arg2 = static_cast<int >(SWIG_As_int(obj1));
7770 if (SWIG_arg_fail(2)) SWIG_fail;
7771 }
7772 if (obj2) {
7773 {
7774 arg3 = static_cast<int >(SWIG_As_int(obj2));
7775 if (SWIG_arg_fail(3)) SWIG_fail;
7776 }
7777 }
7778 {
7779 PyThreadState* __tstate = wxPyBeginAllowThreads();
7780 (arg1)->seek(arg2,arg3);
7781
7782 wxPyEndAllowThreads(__tstate);
7783 if (PyErr_Occurred()) SWIG_fail;
7784 }
7785 Py_INCREF(Py_None); resultobj = Py_None;
7786 return resultobj;
7787 fail:
7788 return NULL;
7789 }
7790
7791
7792 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7793 PyObject *resultobj = NULL;
7794 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7795 int result;
7796 PyObject * obj0 = 0 ;
7797 char *kwnames[] = {
7798 (char *) "self", NULL
7799 };
7800
7801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7803 if (SWIG_arg_fail(1)) SWIG_fail;
7804 {
7805 PyThreadState* __tstate = wxPyBeginAllowThreads();
7806 result = (int)(arg1)->tell();
7807
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 {
7812 resultobj = SWIG_From_int(static_cast<int >(result));
7813 }
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj = NULL;
7822 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7823 char result;
7824 PyObject * obj0 = 0 ;
7825 char *kwnames[] = {
7826 (char *) "self", NULL
7827 };
7828
7829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7831 if (SWIG_arg_fail(1)) SWIG_fail;
7832 {
7833 PyThreadState* __tstate = wxPyBeginAllowThreads();
7834 result = (char)(arg1)->Peek();
7835
7836 wxPyEndAllowThreads(__tstate);
7837 if (PyErr_Occurred()) SWIG_fail;
7838 }
7839 {
7840 resultobj = SWIG_From_char(static_cast<char >(result));
7841 }
7842 return resultobj;
7843 fail:
7844 return NULL;
7845 }
7846
7847
7848 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7849 PyObject *resultobj = NULL;
7850 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7851 char result;
7852 PyObject * obj0 = 0 ;
7853 char *kwnames[] = {
7854 (char *) "self", NULL
7855 };
7856
7857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7859 if (SWIG_arg_fail(1)) SWIG_fail;
7860 {
7861 PyThreadState* __tstate = wxPyBeginAllowThreads();
7862 result = (char)(arg1)->GetC();
7863
7864 wxPyEndAllowThreads(__tstate);
7865 if (PyErr_Occurred()) SWIG_fail;
7866 }
7867 {
7868 resultobj = SWIG_From_char(static_cast<char >(result));
7869 }
7870 return resultobj;
7871 fail:
7872 return NULL;
7873 }
7874
7875
7876 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7877 PyObject *resultobj = NULL;
7878 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7879 size_t result;
7880 PyObject * obj0 = 0 ;
7881 char *kwnames[] = {
7882 (char *) "self", NULL
7883 };
7884
7885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7887 if (SWIG_arg_fail(1)) SWIG_fail;
7888 {
7889 PyThreadState* __tstate = wxPyBeginAllowThreads();
7890 result = (size_t)(arg1)->LastRead();
7891
7892 wxPyEndAllowThreads(__tstate);
7893 if (PyErr_Occurred()) SWIG_fail;
7894 }
7895 {
7896 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7897 }
7898 return resultobj;
7899 fail:
7900 return NULL;
7901 }
7902
7903
7904 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7905 PyObject *resultobj = NULL;
7906 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7907 bool result;
7908 PyObject * obj0 = 0 ;
7909 char *kwnames[] = {
7910 (char *) "self", NULL
7911 };
7912
7913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7915 if (SWIG_arg_fail(1)) SWIG_fail;
7916 {
7917 PyThreadState* __tstate = wxPyBeginAllowThreads();
7918 result = (bool)(arg1)->CanRead();
7919
7920 wxPyEndAllowThreads(__tstate);
7921 if (PyErr_Occurred()) SWIG_fail;
7922 }
7923 {
7924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7925 }
7926 return resultobj;
7927 fail:
7928 return NULL;
7929 }
7930
7931
7932 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7933 PyObject *resultobj = NULL;
7934 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7935 bool result;
7936 PyObject * obj0 = 0 ;
7937 char *kwnames[] = {
7938 (char *) "self", NULL
7939 };
7940
7941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7943 if (SWIG_arg_fail(1)) SWIG_fail;
7944 {
7945 PyThreadState* __tstate = wxPyBeginAllowThreads();
7946 result = (bool)(arg1)->Eof();
7947
7948 wxPyEndAllowThreads(__tstate);
7949 if (PyErr_Occurred()) SWIG_fail;
7950 }
7951 {
7952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7953 }
7954 return resultobj;
7955 fail:
7956 return NULL;
7957 }
7958
7959
7960 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7961 PyObject *resultobj = NULL;
7962 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7963 char arg2 ;
7964 bool result;
7965 PyObject * obj0 = 0 ;
7966 PyObject * obj1 = 0 ;
7967 char *kwnames[] = {
7968 (char *) "self",(char *) "c", NULL
7969 };
7970
7971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7973 if (SWIG_arg_fail(1)) SWIG_fail;
7974 {
7975 arg2 = static_cast<char >(SWIG_As_char(obj1));
7976 if (SWIG_arg_fail(2)) SWIG_fail;
7977 }
7978 {
7979 PyThreadState* __tstate = wxPyBeginAllowThreads();
7980 result = (bool)(arg1)->Ungetch(arg2);
7981
7982 wxPyEndAllowThreads(__tstate);
7983 if (PyErr_Occurred()) SWIG_fail;
7984 }
7985 {
7986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7987 }
7988 return resultobj;
7989 fail:
7990 return NULL;
7991 }
7992
7993
7994 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7995 PyObject *resultobj = NULL;
7996 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7997 long arg2 ;
7998 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7999 long result;
8000 PyObject * obj0 = 0 ;
8001 PyObject * obj1 = 0 ;
8002 PyObject * obj2 = 0 ;
8003 char *kwnames[] = {
8004 (char *) "self",(char *) "pos",(char *) "mode", NULL
8005 };
8006
8007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
8008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8009 if (SWIG_arg_fail(1)) SWIG_fail;
8010 {
8011 arg2 = static_cast<long >(SWIG_As_long(obj1));
8012 if (SWIG_arg_fail(2)) SWIG_fail;
8013 }
8014 if (obj2) {
8015 {
8016 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
8017 if (SWIG_arg_fail(3)) SWIG_fail;
8018 }
8019 }
8020 {
8021 PyThreadState* __tstate = wxPyBeginAllowThreads();
8022 result = (long)(arg1)->SeekI(arg2,arg3);
8023
8024 wxPyEndAllowThreads(__tstate);
8025 if (PyErr_Occurred()) SWIG_fail;
8026 }
8027 {
8028 resultobj = SWIG_From_long(static_cast<long >(result));
8029 }
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8037 PyObject *resultobj = NULL;
8038 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8039 long result;
8040 PyObject * obj0 = 0 ;
8041 char *kwnames[] = {
8042 (char *) "self", NULL
8043 };
8044
8045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8047 if (SWIG_arg_fail(1)) SWIG_fail;
8048 {
8049 PyThreadState* __tstate = wxPyBeginAllowThreads();
8050 result = (long)(arg1)->TellI();
8051
8052 wxPyEndAllowThreads(__tstate);
8053 if (PyErr_Occurred()) SWIG_fail;
8054 }
8055 {
8056 resultobj = SWIG_From_long(static_cast<long >(result));
8057 }
8058 return resultobj;
8059 fail:
8060 return NULL;
8061 }
8062
8063
8064 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8065 PyObject *obj;
8066 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8067 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8068 Py_INCREF(obj);
8069 return Py_BuildValue((char *)"");
8070 }
8071 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8072 PyObject *resultobj = NULL;
8073 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8074 PyObject *arg2 = (PyObject *) 0 ;
8075 PyObject * obj0 = 0 ;
8076 PyObject * obj1 = 0 ;
8077 char *kwnames[] = {
8078 (char *) "self",(char *) "obj", NULL
8079 };
8080
8081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8083 if (SWIG_arg_fail(1)) SWIG_fail;
8084 arg2 = obj1;
8085 {
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 wxOutputStream_write(arg1,arg2);
8088
8089 wxPyEndAllowThreads(__tstate);
8090 if (PyErr_Occurred()) SWIG_fail;
8091 }
8092 Py_INCREF(Py_None); resultobj = Py_None;
8093 return resultobj;
8094 fail:
8095 return NULL;
8096 }
8097
8098
8099 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8100 PyObject *obj;
8101 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8102 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8103 Py_INCREF(obj);
8104 return Py_BuildValue((char *)"");
8105 }
8106 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8107 PyObject *resultobj = NULL;
8108 wxInputStream *arg1 = (wxInputStream *) 0 ;
8109 wxString *arg2 = 0 ;
8110 wxString *arg3 = 0 ;
8111 wxString *arg4 = 0 ;
8112 wxDateTime arg5 ;
8113 wxFSFile *result;
8114 wxPyInputStream *temp1 ;
8115 bool temp2 = false ;
8116 bool temp3 = false ;
8117 bool temp4 = false ;
8118 PyObject * obj0 = 0 ;
8119 PyObject * obj1 = 0 ;
8120 PyObject * obj2 = 0 ;
8121 PyObject * obj3 = 0 ;
8122 PyObject * obj4 = 0 ;
8123 char *kwnames[] = {
8124 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8125 };
8126
8127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8128 {
8129 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8130 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8131 } else {
8132 PyErr_Clear(); // clear the failure of the wxPyConvert above
8133 arg1 = wxPyCBInputStream_create(obj0, true);
8134 if (arg1 == NULL) {
8135 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8136 SWIG_fail;
8137 }
8138 }
8139 }
8140 {
8141 arg2 = wxString_in_helper(obj1);
8142 if (arg2 == NULL) SWIG_fail;
8143 temp2 = true;
8144 }
8145 {
8146 arg3 = wxString_in_helper(obj2);
8147 if (arg3 == NULL) SWIG_fail;
8148 temp3 = true;
8149 }
8150 {
8151 arg4 = wxString_in_helper(obj3);
8152 if (arg4 == NULL) SWIG_fail;
8153 temp4 = true;
8154 }
8155 {
8156 wxDateTime * argp;
8157 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8158 if (SWIG_arg_fail(5)) SWIG_fail;
8159 if (argp == NULL) {
8160 SWIG_null_ref("wxDateTime");
8161 }
8162 if (SWIG_arg_fail(5)) SWIG_fail;
8163 arg5 = *argp;
8164 }
8165 {
8166 PyThreadState* __tstate = wxPyBeginAllowThreads();
8167 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8168
8169 wxPyEndAllowThreads(__tstate);
8170 if (PyErr_Occurred()) SWIG_fail;
8171 }
8172 {
8173 resultobj = wxPyMake_wxObject(result, (bool)1);
8174 }
8175 {
8176 if (temp2)
8177 delete arg2;
8178 }
8179 {
8180 if (temp3)
8181 delete arg3;
8182 }
8183 {
8184 if (temp4)
8185 delete arg4;
8186 }
8187 return resultobj;
8188 fail:
8189 {
8190 if (temp2)
8191 delete arg2;
8192 }
8193 {
8194 if (temp3)
8195 delete arg3;
8196 }
8197 {
8198 if (temp4)
8199 delete arg4;
8200 }
8201 return NULL;
8202 }
8203
8204
8205 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8206 PyObject *resultobj = NULL;
8207 wxFSFile *arg1 = (wxFSFile *) 0 ;
8208 PyObject * obj0 = 0 ;
8209 char *kwnames[] = {
8210 (char *) "self", NULL
8211 };
8212
8213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8215 if (SWIG_arg_fail(1)) SWIG_fail;
8216 {
8217 PyThreadState* __tstate = wxPyBeginAllowThreads();
8218 delete arg1;
8219
8220 wxPyEndAllowThreads(__tstate);
8221 if (PyErr_Occurred()) SWIG_fail;
8222 }
8223 Py_INCREF(Py_None); resultobj = Py_None;
8224 return resultobj;
8225 fail:
8226 return NULL;
8227 }
8228
8229
8230 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8231 PyObject *resultobj = NULL;
8232 wxFSFile *arg1 = (wxFSFile *) 0 ;
8233 wxInputStream *result;
8234 PyObject * obj0 = 0 ;
8235 char *kwnames[] = {
8236 (char *) "self", NULL
8237 };
8238
8239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8241 if (SWIG_arg_fail(1)) SWIG_fail;
8242 {
8243 PyThreadState* __tstate = wxPyBeginAllowThreads();
8244 result = (wxInputStream *)(arg1)->GetStream();
8245
8246 wxPyEndAllowThreads(__tstate);
8247 if (PyErr_Occurred()) SWIG_fail;
8248 }
8249 {
8250 wxPyInputStream * _ptr = NULL;
8251
8252 if (result) {
8253 _ptr = new wxPyInputStream(result);
8254 }
8255 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8256 }
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = NULL;
8265 wxFSFile *arg1 = (wxFSFile *) 0 ;
8266 wxString *result;
8267 PyObject * obj0 = 0 ;
8268 char *kwnames[] = {
8269 (char *) "self", NULL
8270 };
8271
8272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8274 if (SWIG_arg_fail(1)) SWIG_fail;
8275 {
8276 PyThreadState* __tstate = wxPyBeginAllowThreads();
8277 {
8278 wxString const &_result_ref = (arg1)->GetMimeType();
8279 result = (wxString *) &_result_ref;
8280 }
8281
8282 wxPyEndAllowThreads(__tstate);
8283 if (PyErr_Occurred()) SWIG_fail;
8284 }
8285 {
8286 #if wxUSE_UNICODE
8287 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8288 #else
8289 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8290 #endif
8291 }
8292 return resultobj;
8293 fail:
8294 return NULL;
8295 }
8296
8297
8298 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8299 PyObject *resultobj = NULL;
8300 wxFSFile *arg1 = (wxFSFile *) 0 ;
8301 wxString *result;
8302 PyObject * obj0 = 0 ;
8303 char *kwnames[] = {
8304 (char *) "self", NULL
8305 };
8306
8307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8309 if (SWIG_arg_fail(1)) SWIG_fail;
8310 {
8311 PyThreadState* __tstate = wxPyBeginAllowThreads();
8312 {
8313 wxString const &_result_ref = (arg1)->GetLocation();
8314 result = (wxString *) &_result_ref;
8315 }
8316
8317 wxPyEndAllowThreads(__tstate);
8318 if (PyErr_Occurred()) SWIG_fail;
8319 }
8320 {
8321 #if wxUSE_UNICODE
8322 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8323 #else
8324 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8325 #endif
8326 }
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
8333 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8334 PyObject *resultobj = NULL;
8335 wxFSFile *arg1 = (wxFSFile *) 0 ;
8336 wxString *result;
8337 PyObject * obj0 = 0 ;
8338 char *kwnames[] = {
8339 (char *) "self", NULL
8340 };
8341
8342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8344 if (SWIG_arg_fail(1)) SWIG_fail;
8345 {
8346 PyThreadState* __tstate = wxPyBeginAllowThreads();
8347 {
8348 wxString const &_result_ref = (arg1)->GetAnchor();
8349 result = (wxString *) &_result_ref;
8350 }
8351
8352 wxPyEndAllowThreads(__tstate);
8353 if (PyErr_Occurred()) SWIG_fail;
8354 }
8355 {
8356 #if wxUSE_UNICODE
8357 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8358 #else
8359 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8360 #endif
8361 }
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj = NULL;
8370 wxFSFile *arg1 = (wxFSFile *) 0 ;
8371 wxDateTime result;
8372 PyObject * obj0 = 0 ;
8373 char *kwnames[] = {
8374 (char *) "self", NULL
8375 };
8376
8377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8379 if (SWIG_arg_fail(1)) SWIG_fail;
8380 {
8381 PyThreadState* __tstate = wxPyBeginAllowThreads();
8382 result = (arg1)->GetModificationTime();
8383
8384 wxPyEndAllowThreads(__tstate);
8385 if (PyErr_Occurred()) SWIG_fail;
8386 }
8387 {
8388 wxDateTime * resultptr;
8389 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8390 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8391 }
8392 return resultobj;
8393 fail:
8394 return NULL;
8395 }
8396
8397
8398 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8399 PyObject *obj;
8400 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8401 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8402 Py_INCREF(obj);
8403 return Py_BuildValue((char *)"");
8404 }
8405 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8406 PyObject *obj;
8407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8408 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8409 Py_INCREF(obj);
8410 return Py_BuildValue((char *)"");
8411 }
8412 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8413 PyObject *resultobj = NULL;
8414 wxPyFileSystemHandler *result;
8415 char *kwnames[] = {
8416 NULL
8417 };
8418
8419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8420 {
8421 PyThreadState* __tstate = wxPyBeginAllowThreads();
8422 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8423
8424 wxPyEndAllowThreads(__tstate);
8425 if (PyErr_Occurred()) SWIG_fail;
8426 }
8427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj = NULL;
8436 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8437 PyObject *arg2 = (PyObject *) 0 ;
8438 PyObject *arg3 = (PyObject *) 0 ;
8439 PyObject * obj0 = 0 ;
8440 PyObject * obj1 = 0 ;
8441 PyObject * obj2 = 0 ;
8442 char *kwnames[] = {
8443 (char *) "self",(char *) "self",(char *) "_class", NULL
8444 };
8445
8446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8448 if (SWIG_arg_fail(1)) SWIG_fail;
8449 arg2 = obj1;
8450 arg3 = obj2;
8451 {
8452 PyThreadState* __tstate = wxPyBeginAllowThreads();
8453 (arg1)->_setCallbackInfo(arg2,arg3);
8454
8455 wxPyEndAllowThreads(__tstate);
8456 if (PyErr_Occurred()) SWIG_fail;
8457 }
8458 Py_INCREF(Py_None); resultobj = Py_None;
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj = NULL;
8467 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8468 wxString *arg2 = 0 ;
8469 bool result;
8470 bool temp2 = false ;
8471 PyObject * obj0 = 0 ;
8472 PyObject * obj1 = 0 ;
8473 char *kwnames[] = {
8474 (char *) "self",(char *) "location", NULL
8475 };
8476
8477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8479 if (SWIG_arg_fail(1)) SWIG_fail;
8480 {
8481 arg2 = wxString_in_helper(obj1);
8482 if (arg2 == NULL) SWIG_fail;
8483 temp2 = true;
8484 }
8485 {
8486 PyThreadState* __tstate = wxPyBeginAllowThreads();
8487 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8488
8489 wxPyEndAllowThreads(__tstate);
8490 if (PyErr_Occurred()) SWIG_fail;
8491 }
8492 {
8493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8494 }
8495 {
8496 if (temp2)
8497 delete arg2;
8498 }
8499 return resultobj;
8500 fail:
8501 {
8502 if (temp2)
8503 delete arg2;
8504 }
8505 return NULL;
8506 }
8507
8508
8509 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8510 PyObject *resultobj = NULL;
8511 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8512 wxFileSystem *arg2 = 0 ;
8513 wxString *arg3 = 0 ;
8514 wxFSFile *result;
8515 bool temp3 = false ;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 PyObject * obj2 = 0 ;
8519 char *kwnames[] = {
8520 (char *) "self",(char *) "fs",(char *) "location", NULL
8521 };
8522
8523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8525 if (SWIG_arg_fail(1)) SWIG_fail;
8526 {
8527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8528 if (SWIG_arg_fail(2)) SWIG_fail;
8529 if (arg2 == NULL) {
8530 SWIG_null_ref("wxFileSystem");
8531 }
8532 if (SWIG_arg_fail(2)) SWIG_fail;
8533 }
8534 {
8535 arg3 = wxString_in_helper(obj2);
8536 if (arg3 == NULL) SWIG_fail;
8537 temp3 = true;
8538 }
8539 {
8540 PyThreadState* __tstate = wxPyBeginAllowThreads();
8541 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8542
8543 wxPyEndAllowThreads(__tstate);
8544 if (PyErr_Occurred()) SWIG_fail;
8545 }
8546 {
8547 resultobj = wxPyMake_wxObject(result, (bool)1);
8548 }
8549 {
8550 if (temp3)
8551 delete arg3;
8552 }
8553 return resultobj;
8554 fail:
8555 {
8556 if (temp3)
8557 delete arg3;
8558 }
8559 return NULL;
8560 }
8561
8562
8563 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8564 PyObject *resultobj = NULL;
8565 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8566 wxString *arg2 = 0 ;
8567 int arg3 = (int) 0 ;
8568 wxString result;
8569 bool temp2 = false ;
8570 PyObject * obj0 = 0 ;
8571 PyObject * obj1 = 0 ;
8572 PyObject * obj2 = 0 ;
8573 char *kwnames[] = {
8574 (char *) "self",(char *) "spec",(char *) "flags", NULL
8575 };
8576
8577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8579 if (SWIG_arg_fail(1)) SWIG_fail;
8580 {
8581 arg2 = wxString_in_helper(obj1);
8582 if (arg2 == NULL) SWIG_fail;
8583 temp2 = true;
8584 }
8585 if (obj2) {
8586 {
8587 arg3 = static_cast<int >(SWIG_As_int(obj2));
8588 if (SWIG_arg_fail(3)) SWIG_fail;
8589 }
8590 }
8591 {
8592 PyThreadState* __tstate = wxPyBeginAllowThreads();
8593 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8594
8595 wxPyEndAllowThreads(__tstate);
8596 if (PyErr_Occurred()) SWIG_fail;
8597 }
8598 {
8599 #if wxUSE_UNICODE
8600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8601 #else
8602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8603 #endif
8604 }
8605 {
8606 if (temp2)
8607 delete arg2;
8608 }
8609 return resultobj;
8610 fail:
8611 {
8612 if (temp2)
8613 delete arg2;
8614 }
8615 return NULL;
8616 }
8617
8618
8619 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8620 PyObject *resultobj = NULL;
8621 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8622 wxString result;
8623 PyObject * obj0 = 0 ;
8624 char *kwnames[] = {
8625 (char *) "self", NULL
8626 };
8627
8628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8630 if (SWIG_arg_fail(1)) SWIG_fail;
8631 {
8632 PyThreadState* __tstate = wxPyBeginAllowThreads();
8633 result = (arg1)->FindNext();
8634
8635 wxPyEndAllowThreads(__tstate);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 {
8639 #if wxUSE_UNICODE
8640 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8641 #else
8642 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8643 #endif
8644 }
8645 return resultobj;
8646 fail:
8647 return NULL;
8648 }
8649
8650
8651 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8652 PyObject *resultobj = NULL;
8653 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8654 wxString *arg2 = 0 ;
8655 wxString result;
8656 bool temp2 = false ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char *kwnames[] = {
8660 (char *) "self",(char *) "location", NULL
8661 };
8662
8663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8665 if (SWIG_arg_fail(1)) SWIG_fail;
8666 {
8667 arg2 = wxString_in_helper(obj1);
8668 if (arg2 == NULL) SWIG_fail;
8669 temp2 = true;
8670 }
8671 {
8672 PyThreadState* __tstate = wxPyBeginAllowThreads();
8673 result = (arg1)->GetProtocol((wxString const &)*arg2);
8674
8675 wxPyEndAllowThreads(__tstate);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 {
8679 #if wxUSE_UNICODE
8680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8681 #else
8682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8683 #endif
8684 }
8685 {
8686 if (temp2)
8687 delete arg2;
8688 }
8689 return resultobj;
8690 fail:
8691 {
8692 if (temp2)
8693 delete arg2;
8694 }
8695 return NULL;
8696 }
8697
8698
8699 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8700 PyObject *resultobj = NULL;
8701 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8702 wxString *arg2 = 0 ;
8703 wxString result;
8704 bool temp2 = false ;
8705 PyObject * obj0 = 0 ;
8706 PyObject * obj1 = 0 ;
8707 char *kwnames[] = {
8708 (char *) "self",(char *) "location", NULL
8709 };
8710
8711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8713 if (SWIG_arg_fail(1)) SWIG_fail;
8714 {
8715 arg2 = wxString_in_helper(obj1);
8716 if (arg2 == NULL) SWIG_fail;
8717 temp2 = true;
8718 }
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8722
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 {
8727 #if wxUSE_UNICODE
8728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8729 #else
8730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8731 #endif
8732 }
8733 {
8734 if (temp2)
8735 delete arg2;
8736 }
8737 return resultobj;
8738 fail:
8739 {
8740 if (temp2)
8741 delete arg2;
8742 }
8743 return NULL;
8744 }
8745
8746
8747 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8748 PyObject *resultobj = NULL;
8749 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8750 wxString *arg2 = 0 ;
8751 wxString result;
8752 bool temp2 = false ;
8753 PyObject * obj0 = 0 ;
8754 PyObject * obj1 = 0 ;
8755 char *kwnames[] = {
8756 (char *) "self",(char *) "location", NULL
8757 };
8758
8759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8761 if (SWIG_arg_fail(1)) SWIG_fail;
8762 {
8763 arg2 = wxString_in_helper(obj1);
8764 if (arg2 == NULL) SWIG_fail;
8765 temp2 = true;
8766 }
8767 {
8768 PyThreadState* __tstate = wxPyBeginAllowThreads();
8769 result = (arg1)->GetAnchor((wxString const &)*arg2);
8770
8771 wxPyEndAllowThreads(__tstate);
8772 if (PyErr_Occurred()) SWIG_fail;
8773 }
8774 {
8775 #if wxUSE_UNICODE
8776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8777 #else
8778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8779 #endif
8780 }
8781 {
8782 if (temp2)
8783 delete arg2;
8784 }
8785 return resultobj;
8786 fail:
8787 {
8788 if (temp2)
8789 delete arg2;
8790 }
8791 return NULL;
8792 }
8793
8794
8795 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj = NULL;
8797 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8798 wxString *arg2 = 0 ;
8799 wxString result;
8800 bool temp2 = false ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 char *kwnames[] = {
8804 (char *) "self",(char *) "location", NULL
8805 };
8806
8807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8809 if (SWIG_arg_fail(1)) SWIG_fail;
8810 {
8811 arg2 = wxString_in_helper(obj1);
8812 if (arg2 == NULL) SWIG_fail;
8813 temp2 = true;
8814 }
8815 {
8816 PyThreadState* __tstate = wxPyBeginAllowThreads();
8817 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8818
8819 wxPyEndAllowThreads(__tstate);
8820 if (PyErr_Occurred()) SWIG_fail;
8821 }
8822 {
8823 #if wxUSE_UNICODE
8824 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8825 #else
8826 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8827 #endif
8828 }
8829 {
8830 if (temp2)
8831 delete arg2;
8832 }
8833 return resultobj;
8834 fail:
8835 {
8836 if (temp2)
8837 delete arg2;
8838 }
8839 return NULL;
8840 }
8841
8842
8843 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8844 PyObject *resultobj = NULL;
8845 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8846 wxString *arg2 = 0 ;
8847 wxString result;
8848 bool temp2 = false ;
8849 PyObject * obj0 = 0 ;
8850 PyObject * obj1 = 0 ;
8851 char *kwnames[] = {
8852 (char *) "self",(char *) "location", NULL
8853 };
8854
8855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8857 if (SWIG_arg_fail(1)) SWIG_fail;
8858 {
8859 arg2 = wxString_in_helper(obj1);
8860 if (arg2 == NULL) SWIG_fail;
8861 temp2 = true;
8862 }
8863 {
8864 PyThreadState* __tstate = wxPyBeginAllowThreads();
8865 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8866
8867 wxPyEndAllowThreads(__tstate);
8868 if (PyErr_Occurred()) SWIG_fail;
8869 }
8870 {
8871 #if wxUSE_UNICODE
8872 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8873 #else
8874 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8875 #endif
8876 }
8877 {
8878 if (temp2)
8879 delete arg2;
8880 }
8881 return resultobj;
8882 fail:
8883 {
8884 if (temp2)
8885 delete arg2;
8886 }
8887 return NULL;
8888 }
8889
8890
8891 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8892 PyObject *obj;
8893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8894 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8895 Py_INCREF(obj);
8896 return Py_BuildValue((char *)"");
8897 }
8898 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8899 PyObject *resultobj = NULL;
8900 wxFileSystem *result;
8901 char *kwnames[] = {
8902 NULL
8903 };
8904
8905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8906 {
8907 PyThreadState* __tstate = wxPyBeginAllowThreads();
8908 result = (wxFileSystem *)new wxFileSystem();
8909
8910 wxPyEndAllowThreads(__tstate);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 {
8914 resultobj = wxPyMake_wxObject(result, (bool)1);
8915 }
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8923 PyObject *resultobj = NULL;
8924 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8925 PyObject * obj0 = 0 ;
8926 char *kwnames[] = {
8927 (char *) "self", NULL
8928 };
8929
8930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8932 if (SWIG_arg_fail(1)) SWIG_fail;
8933 {
8934 PyThreadState* __tstate = wxPyBeginAllowThreads();
8935 delete arg1;
8936
8937 wxPyEndAllowThreads(__tstate);
8938 if (PyErr_Occurred()) SWIG_fail;
8939 }
8940 Py_INCREF(Py_None); resultobj = Py_None;
8941 return resultobj;
8942 fail:
8943 return NULL;
8944 }
8945
8946
8947 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8948 PyObject *resultobj = NULL;
8949 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8950 wxString *arg2 = 0 ;
8951 bool arg3 = (bool) false ;
8952 bool temp2 = false ;
8953 PyObject * obj0 = 0 ;
8954 PyObject * obj1 = 0 ;
8955 PyObject * obj2 = 0 ;
8956 char *kwnames[] = {
8957 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8958 };
8959
8960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8962 if (SWIG_arg_fail(1)) SWIG_fail;
8963 {
8964 arg2 = wxString_in_helper(obj1);
8965 if (arg2 == NULL) SWIG_fail;
8966 temp2 = true;
8967 }
8968 if (obj2) {
8969 {
8970 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8971 if (SWIG_arg_fail(3)) SWIG_fail;
8972 }
8973 }
8974 {
8975 PyThreadState* __tstate = wxPyBeginAllowThreads();
8976 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8977
8978 wxPyEndAllowThreads(__tstate);
8979 if (PyErr_Occurred()) SWIG_fail;
8980 }
8981 Py_INCREF(Py_None); resultobj = Py_None;
8982 {
8983 if (temp2)
8984 delete arg2;
8985 }
8986 return resultobj;
8987 fail:
8988 {
8989 if (temp2)
8990 delete arg2;
8991 }
8992 return NULL;
8993 }
8994
8995
8996 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8997 PyObject *resultobj = NULL;
8998 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8999 wxString result;
9000 PyObject * obj0 = 0 ;
9001 char *kwnames[] = {
9002 (char *) "self", NULL
9003 };
9004
9005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
9006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9007 if (SWIG_arg_fail(1)) SWIG_fail;
9008 {
9009 PyThreadState* __tstate = wxPyBeginAllowThreads();
9010 result = (arg1)->GetPath();
9011
9012 wxPyEndAllowThreads(__tstate);
9013 if (PyErr_Occurred()) SWIG_fail;
9014 }
9015 {
9016 #if wxUSE_UNICODE
9017 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9018 #else
9019 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9020 #endif
9021 }
9022 return resultobj;
9023 fail:
9024 return NULL;
9025 }
9026
9027
9028 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9029 PyObject *resultobj = NULL;
9030 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9031 wxString *arg2 = 0 ;
9032 wxFSFile *result;
9033 bool temp2 = false ;
9034 PyObject * obj0 = 0 ;
9035 PyObject * obj1 = 0 ;
9036 char *kwnames[] = {
9037 (char *) "self",(char *) "location", NULL
9038 };
9039
9040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9042 if (SWIG_arg_fail(1)) SWIG_fail;
9043 {
9044 arg2 = wxString_in_helper(obj1);
9045 if (arg2 == NULL) SWIG_fail;
9046 temp2 = true;
9047 }
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 {
9056 resultobj = wxPyMake_wxObject(result, (bool)1);
9057 }
9058 {
9059 if (temp2)
9060 delete arg2;
9061 }
9062 return resultobj;
9063 fail:
9064 {
9065 if (temp2)
9066 delete arg2;
9067 }
9068 return NULL;
9069 }
9070
9071
9072 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9073 PyObject *resultobj = NULL;
9074 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9075 wxString *arg2 = 0 ;
9076 int arg3 = (int) 0 ;
9077 wxString result;
9078 bool temp2 = false ;
9079 PyObject * obj0 = 0 ;
9080 PyObject * obj1 = 0 ;
9081 PyObject * obj2 = 0 ;
9082 char *kwnames[] = {
9083 (char *) "self",(char *) "spec",(char *) "flags", NULL
9084 };
9085
9086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9088 if (SWIG_arg_fail(1)) SWIG_fail;
9089 {
9090 arg2 = wxString_in_helper(obj1);
9091 if (arg2 == NULL) SWIG_fail;
9092 temp2 = true;
9093 }
9094 if (obj2) {
9095 {
9096 arg3 = static_cast<int >(SWIG_As_int(obj2));
9097 if (SWIG_arg_fail(3)) SWIG_fail;
9098 }
9099 }
9100 {
9101 PyThreadState* __tstate = wxPyBeginAllowThreads();
9102 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9103
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 {
9108 #if wxUSE_UNICODE
9109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9110 #else
9111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9112 #endif
9113 }
9114 {
9115 if (temp2)
9116 delete arg2;
9117 }
9118 return resultobj;
9119 fail:
9120 {
9121 if (temp2)
9122 delete arg2;
9123 }
9124 return NULL;
9125 }
9126
9127
9128 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9129 PyObject *resultobj = NULL;
9130 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9131 wxString result;
9132 PyObject * obj0 = 0 ;
9133 char *kwnames[] = {
9134 (char *) "self", NULL
9135 };
9136
9137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9139 if (SWIG_arg_fail(1)) SWIG_fail;
9140 {
9141 PyThreadState* __tstate = wxPyBeginAllowThreads();
9142 result = (arg1)->FindNext();
9143
9144 wxPyEndAllowThreads(__tstate);
9145 if (PyErr_Occurred()) SWIG_fail;
9146 }
9147 {
9148 #if wxUSE_UNICODE
9149 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9150 #else
9151 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9152 #endif
9153 }
9154 return resultobj;
9155 fail:
9156 return NULL;
9157 }
9158
9159
9160 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9161 PyObject *resultobj = NULL;
9162 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9163 PyObject * obj0 = 0 ;
9164 char *kwnames[] = {
9165 (char *) "handler", NULL
9166 };
9167
9168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9170 if (SWIG_arg_fail(1)) SWIG_fail;
9171 {
9172 PyThreadState* __tstate = wxPyBeginAllowThreads();
9173 wxFileSystem::AddHandler(arg1);
9174
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 Py_INCREF(Py_None); resultobj = Py_None;
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
9185 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj = NULL;
9187 char *kwnames[] = {
9188 NULL
9189 };
9190
9191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9192 {
9193 PyThreadState* __tstate = wxPyBeginAllowThreads();
9194 wxFileSystem::CleanUpHandlers();
9195
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 Py_INCREF(Py_None); resultobj = Py_None;
9200 return resultobj;
9201 fail:
9202 return NULL;
9203 }
9204
9205
9206 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9207 PyObject *resultobj = NULL;
9208 wxString *arg1 = 0 ;
9209 wxString result;
9210 bool temp1 = false ;
9211 PyObject * obj0 = 0 ;
9212 char *kwnames[] = {
9213 (char *) "filename", NULL
9214 };
9215
9216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9217 {
9218 arg1 = wxString_in_helper(obj0);
9219 if (arg1 == NULL) SWIG_fail;
9220 temp1 = true;
9221 }
9222 {
9223 PyThreadState* __tstate = wxPyBeginAllowThreads();
9224 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9225
9226 wxPyEndAllowThreads(__tstate);
9227 if (PyErr_Occurred()) SWIG_fail;
9228 }
9229 {
9230 #if wxUSE_UNICODE
9231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9232 #else
9233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9234 #endif
9235 }
9236 {
9237 if (temp1)
9238 delete arg1;
9239 }
9240 return resultobj;
9241 fail:
9242 {
9243 if (temp1)
9244 delete arg1;
9245 }
9246 return NULL;
9247 }
9248
9249
9250 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9251 PyObject *resultobj = NULL;
9252 wxString *arg1 = 0 ;
9253 wxString result;
9254 bool temp1 = false ;
9255 PyObject * obj0 = 0 ;
9256 char *kwnames[] = {
9257 (char *) "url", NULL
9258 };
9259
9260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9261 {
9262 arg1 = wxString_in_helper(obj0);
9263 if (arg1 == NULL) SWIG_fail;
9264 temp1 = true;
9265 }
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 {
9274 #if wxUSE_UNICODE
9275 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9276 #else
9277 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9278 #endif
9279 }
9280 {
9281 if (temp1)
9282 delete arg1;
9283 }
9284 return resultobj;
9285 fail:
9286 {
9287 if (temp1)
9288 delete arg1;
9289 }
9290 return NULL;
9291 }
9292
9293
9294 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9295 PyObject *obj;
9296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9297 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9298 Py_INCREF(obj);
9299 return Py_BuildValue((char *)"");
9300 }
9301 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9302 PyObject *resultobj = NULL;
9303 wxInternetFSHandler *result;
9304 char *kwnames[] = {
9305 NULL
9306 };
9307
9308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9309 {
9310 PyThreadState* __tstate = wxPyBeginAllowThreads();
9311 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9312
9313 wxPyEndAllowThreads(__tstate);
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9324 PyObject *resultobj = NULL;
9325 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9326 wxString *arg2 = 0 ;
9327 bool result;
9328 bool temp2 = false ;
9329 PyObject * obj0 = 0 ;
9330 PyObject * obj1 = 0 ;
9331 char *kwnames[] = {
9332 (char *) "self",(char *) "location", NULL
9333 };
9334
9335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9337 if (SWIG_arg_fail(1)) SWIG_fail;
9338 {
9339 arg2 = wxString_in_helper(obj1);
9340 if (arg2 == NULL) SWIG_fail;
9341 temp2 = true;
9342 }
9343 {
9344 PyThreadState* __tstate = wxPyBeginAllowThreads();
9345 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9346
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 {
9351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9352 }
9353 {
9354 if (temp2)
9355 delete arg2;
9356 }
9357 return resultobj;
9358 fail:
9359 {
9360 if (temp2)
9361 delete arg2;
9362 }
9363 return NULL;
9364 }
9365
9366
9367 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9368 PyObject *resultobj = NULL;
9369 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9370 wxFileSystem *arg2 = 0 ;
9371 wxString *arg3 = 0 ;
9372 wxFSFile *result;
9373 bool temp3 = false ;
9374 PyObject * obj0 = 0 ;
9375 PyObject * obj1 = 0 ;
9376 PyObject * obj2 = 0 ;
9377 char *kwnames[] = {
9378 (char *) "self",(char *) "fs",(char *) "location", NULL
9379 };
9380
9381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9383 if (SWIG_arg_fail(1)) SWIG_fail;
9384 {
9385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9386 if (SWIG_arg_fail(2)) SWIG_fail;
9387 if (arg2 == NULL) {
9388 SWIG_null_ref("wxFileSystem");
9389 }
9390 if (SWIG_arg_fail(2)) SWIG_fail;
9391 }
9392 {
9393 arg3 = wxString_in_helper(obj2);
9394 if (arg3 == NULL) SWIG_fail;
9395 temp3 = true;
9396 }
9397 {
9398 PyThreadState* __tstate = wxPyBeginAllowThreads();
9399 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9400
9401 wxPyEndAllowThreads(__tstate);
9402 if (PyErr_Occurred()) SWIG_fail;
9403 }
9404 {
9405 resultobj = wxPyMake_wxObject(result, (bool)1);
9406 }
9407 {
9408 if (temp3)
9409 delete arg3;
9410 }
9411 return resultobj;
9412 fail:
9413 {
9414 if (temp3)
9415 delete arg3;
9416 }
9417 return NULL;
9418 }
9419
9420
9421 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9422 PyObject *obj;
9423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9424 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9425 Py_INCREF(obj);
9426 return Py_BuildValue((char *)"");
9427 }
9428 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9429 PyObject *resultobj = NULL;
9430 wxZipFSHandler *result;
9431 char *kwnames[] = {
9432 NULL
9433 };
9434
9435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9436 {
9437 PyThreadState* __tstate = wxPyBeginAllowThreads();
9438 result = (wxZipFSHandler *)new wxZipFSHandler();
9439
9440 wxPyEndAllowThreads(__tstate);
9441 if (PyErr_Occurred()) SWIG_fail;
9442 }
9443 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9444 return resultobj;
9445 fail:
9446 return NULL;
9447 }
9448
9449
9450 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj = NULL;
9452 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9453 wxString *arg2 = 0 ;
9454 bool result;
9455 bool temp2 = false ;
9456 PyObject * obj0 = 0 ;
9457 PyObject * obj1 = 0 ;
9458 char *kwnames[] = {
9459 (char *) "self",(char *) "location", NULL
9460 };
9461
9462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9464 if (SWIG_arg_fail(1)) SWIG_fail;
9465 {
9466 arg2 = wxString_in_helper(obj1);
9467 if (arg2 == NULL) SWIG_fail;
9468 temp2 = true;
9469 }
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9473
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 {
9478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9479 }
9480 {
9481 if (temp2)
9482 delete arg2;
9483 }
9484 return resultobj;
9485 fail:
9486 {
9487 if (temp2)
9488 delete arg2;
9489 }
9490 return NULL;
9491 }
9492
9493
9494 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj = NULL;
9496 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9497 wxFileSystem *arg2 = 0 ;
9498 wxString *arg3 = 0 ;
9499 wxFSFile *result;
9500 bool temp3 = false ;
9501 PyObject * obj0 = 0 ;
9502 PyObject * obj1 = 0 ;
9503 PyObject * obj2 = 0 ;
9504 char *kwnames[] = {
9505 (char *) "self",(char *) "fs",(char *) "location", NULL
9506 };
9507
9508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9510 if (SWIG_arg_fail(1)) SWIG_fail;
9511 {
9512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9513 if (SWIG_arg_fail(2)) SWIG_fail;
9514 if (arg2 == NULL) {
9515 SWIG_null_ref("wxFileSystem");
9516 }
9517 if (SWIG_arg_fail(2)) SWIG_fail;
9518 }
9519 {
9520 arg3 = wxString_in_helper(obj2);
9521 if (arg3 == NULL) SWIG_fail;
9522 temp3 = true;
9523 }
9524 {
9525 PyThreadState* __tstate = wxPyBeginAllowThreads();
9526 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9527
9528 wxPyEndAllowThreads(__tstate);
9529 if (PyErr_Occurred()) SWIG_fail;
9530 }
9531 {
9532 resultobj = wxPyMake_wxObject(result, (bool)1);
9533 }
9534 {
9535 if (temp3)
9536 delete arg3;
9537 }
9538 return resultobj;
9539 fail:
9540 {
9541 if (temp3)
9542 delete arg3;
9543 }
9544 return NULL;
9545 }
9546
9547
9548 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9549 PyObject *resultobj = NULL;
9550 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9551 wxString *arg2 = 0 ;
9552 int arg3 = (int) 0 ;
9553 wxString result;
9554 bool temp2 = false ;
9555 PyObject * obj0 = 0 ;
9556 PyObject * obj1 = 0 ;
9557 PyObject * obj2 = 0 ;
9558 char *kwnames[] = {
9559 (char *) "self",(char *) "spec",(char *) "flags", NULL
9560 };
9561
9562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9564 if (SWIG_arg_fail(1)) SWIG_fail;
9565 {
9566 arg2 = wxString_in_helper(obj1);
9567 if (arg2 == NULL) SWIG_fail;
9568 temp2 = true;
9569 }
9570 if (obj2) {
9571 {
9572 arg3 = static_cast<int >(SWIG_As_int(obj2));
9573 if (SWIG_arg_fail(3)) SWIG_fail;
9574 }
9575 }
9576 {
9577 PyThreadState* __tstate = wxPyBeginAllowThreads();
9578 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9579
9580 wxPyEndAllowThreads(__tstate);
9581 if (PyErr_Occurred()) SWIG_fail;
9582 }
9583 {
9584 #if wxUSE_UNICODE
9585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9586 #else
9587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9588 #endif
9589 }
9590 {
9591 if (temp2)
9592 delete arg2;
9593 }
9594 return resultobj;
9595 fail:
9596 {
9597 if (temp2)
9598 delete arg2;
9599 }
9600 return NULL;
9601 }
9602
9603
9604 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9605 PyObject *resultobj = NULL;
9606 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9607 wxString result;
9608 PyObject * obj0 = 0 ;
9609 char *kwnames[] = {
9610 (char *) "self", NULL
9611 };
9612
9613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9615 if (SWIG_arg_fail(1)) SWIG_fail;
9616 {
9617 PyThreadState* __tstate = wxPyBeginAllowThreads();
9618 result = (arg1)->FindNext();
9619
9620 wxPyEndAllowThreads(__tstate);
9621 if (PyErr_Occurred()) SWIG_fail;
9622 }
9623 {
9624 #if wxUSE_UNICODE
9625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9626 #else
9627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9628 #endif
9629 }
9630 return resultobj;
9631 fail:
9632 return NULL;
9633 }
9634
9635
9636 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9637 PyObject *obj;
9638 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9639 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9640 Py_INCREF(obj);
9641 return Py_BuildValue((char *)"");
9642 }
9643 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9644 PyObject *resultobj = NULL;
9645 wxString *arg1 = 0 ;
9646 wxImage *arg2 = 0 ;
9647 long arg3 ;
9648 bool temp1 = false ;
9649 PyObject * obj0 = 0 ;
9650 PyObject * obj1 = 0 ;
9651 PyObject * obj2 = 0 ;
9652 char *kwnames[] = {
9653 (char *) "filename",(char *) "image",(char *) "type", NULL
9654 };
9655
9656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9657 {
9658 arg1 = wxString_in_helper(obj0);
9659 if (arg1 == NULL) SWIG_fail;
9660 temp1 = true;
9661 }
9662 {
9663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9664 if (SWIG_arg_fail(2)) SWIG_fail;
9665 if (arg2 == NULL) {
9666 SWIG_null_ref("wxImage");
9667 }
9668 if (SWIG_arg_fail(2)) SWIG_fail;
9669 }
9670 {
9671 arg3 = static_cast<long >(SWIG_As_long(obj2));
9672 if (SWIG_arg_fail(3)) SWIG_fail;
9673 }
9674 {
9675 PyThreadState* __tstate = wxPyBeginAllowThreads();
9676 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9677
9678 wxPyEndAllowThreads(__tstate);
9679 if (PyErr_Occurred()) SWIG_fail;
9680 }
9681 Py_INCREF(Py_None); resultobj = Py_None;
9682 {
9683 if (temp1)
9684 delete arg1;
9685 }
9686 return resultobj;
9687 fail:
9688 {
9689 if (temp1)
9690 delete arg1;
9691 }
9692 return NULL;
9693 }
9694
9695
9696 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9697 PyObject *resultobj = NULL;
9698 wxString *arg1 = 0 ;
9699 wxBitmap *arg2 = 0 ;
9700 long arg3 ;
9701 bool temp1 = false ;
9702 PyObject * obj0 = 0 ;
9703 PyObject * obj1 = 0 ;
9704 PyObject * obj2 = 0 ;
9705 char *kwnames[] = {
9706 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9707 };
9708
9709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9710 {
9711 arg1 = wxString_in_helper(obj0);
9712 if (arg1 == NULL) SWIG_fail;
9713 temp1 = true;
9714 }
9715 {
9716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9717 if (SWIG_arg_fail(2)) SWIG_fail;
9718 if (arg2 == NULL) {
9719 SWIG_null_ref("wxBitmap");
9720 }
9721 if (SWIG_arg_fail(2)) SWIG_fail;
9722 }
9723 {
9724 arg3 = static_cast<long >(SWIG_As_long(obj2));
9725 if (SWIG_arg_fail(3)) SWIG_fail;
9726 }
9727 {
9728 PyThreadState* __tstate = wxPyBeginAllowThreads();
9729 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9730
9731 wxPyEndAllowThreads(__tstate);
9732 if (PyErr_Occurred()) SWIG_fail;
9733 }
9734 Py_INCREF(Py_None); resultobj = Py_None;
9735 {
9736 if (temp1)
9737 delete arg1;
9738 }
9739 return resultobj;
9740 fail:
9741 {
9742 if (temp1)
9743 delete arg1;
9744 }
9745 return NULL;
9746 }
9747
9748
9749 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9750 PyObject *resultobj = NULL;
9751 wxString *arg1 = 0 ;
9752 PyObject *arg2 = (PyObject *) 0 ;
9753 bool temp1 = false ;
9754 PyObject * obj0 = 0 ;
9755 PyObject * obj1 = 0 ;
9756 char *kwnames[] = {
9757 (char *) "filename",(char *) "data", NULL
9758 };
9759
9760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9761 {
9762 arg1 = wxString_in_helper(obj0);
9763 if (arg1 == NULL) SWIG_fail;
9764 temp1 = true;
9765 }
9766 arg2 = obj1;
9767 {
9768 PyThreadState* __tstate = wxPyBeginAllowThreads();
9769 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9770
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 Py_INCREF(Py_None); resultobj = Py_None;
9775 {
9776 if (temp1)
9777 delete arg1;
9778 }
9779 return resultobj;
9780 fail:
9781 {
9782 if (temp1)
9783 delete arg1;
9784 }
9785 return NULL;
9786 }
9787
9788
9789 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9790 PyObject *resultobj = NULL;
9791 wxMemoryFSHandler *result;
9792 char *kwnames[] = {
9793 NULL
9794 };
9795
9796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9797 {
9798 PyThreadState* __tstate = wxPyBeginAllowThreads();
9799 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9800
9801 wxPyEndAllowThreads(__tstate);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9805 return resultobj;
9806 fail:
9807 return NULL;
9808 }
9809
9810
9811 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9812 PyObject *resultobj = NULL;
9813 wxString *arg1 = 0 ;
9814 bool temp1 = false ;
9815 PyObject * obj0 = 0 ;
9816 char *kwnames[] = {
9817 (char *) "filename", NULL
9818 };
9819
9820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9821 {
9822 arg1 = wxString_in_helper(obj0);
9823 if (arg1 == NULL) SWIG_fail;
9824 temp1 = true;
9825 }
9826 {
9827 PyThreadState* __tstate = wxPyBeginAllowThreads();
9828 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9829
9830 wxPyEndAllowThreads(__tstate);
9831 if (PyErr_Occurred()) SWIG_fail;
9832 }
9833 Py_INCREF(Py_None); resultobj = Py_None;
9834 {
9835 if (temp1)
9836 delete arg1;
9837 }
9838 return resultobj;
9839 fail:
9840 {
9841 if (temp1)
9842 delete arg1;
9843 }
9844 return NULL;
9845 }
9846
9847
9848 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9849 PyObject *resultobj = NULL;
9850 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9851 wxString *arg2 = 0 ;
9852 bool result;
9853 bool temp2 = false ;
9854 PyObject * obj0 = 0 ;
9855 PyObject * obj1 = 0 ;
9856 char *kwnames[] = {
9857 (char *) "self",(char *) "location", NULL
9858 };
9859
9860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9862 if (SWIG_arg_fail(1)) SWIG_fail;
9863 {
9864 arg2 = wxString_in_helper(obj1);
9865 if (arg2 == NULL) SWIG_fail;
9866 temp2 = true;
9867 }
9868 {
9869 PyThreadState* __tstate = wxPyBeginAllowThreads();
9870 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9871
9872 wxPyEndAllowThreads(__tstate);
9873 if (PyErr_Occurred()) SWIG_fail;
9874 }
9875 {
9876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9877 }
9878 {
9879 if (temp2)
9880 delete arg2;
9881 }
9882 return resultobj;
9883 fail:
9884 {
9885 if (temp2)
9886 delete arg2;
9887 }
9888 return NULL;
9889 }
9890
9891
9892 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9893 PyObject *resultobj = NULL;
9894 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9895 wxFileSystem *arg2 = 0 ;
9896 wxString *arg3 = 0 ;
9897 wxFSFile *result;
9898 bool temp3 = false ;
9899 PyObject * obj0 = 0 ;
9900 PyObject * obj1 = 0 ;
9901 PyObject * obj2 = 0 ;
9902 char *kwnames[] = {
9903 (char *) "self",(char *) "fs",(char *) "location", NULL
9904 };
9905
9906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9908 if (SWIG_arg_fail(1)) SWIG_fail;
9909 {
9910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9911 if (SWIG_arg_fail(2)) SWIG_fail;
9912 if (arg2 == NULL) {
9913 SWIG_null_ref("wxFileSystem");
9914 }
9915 if (SWIG_arg_fail(2)) SWIG_fail;
9916 }
9917 {
9918 arg3 = wxString_in_helper(obj2);
9919 if (arg3 == NULL) SWIG_fail;
9920 temp3 = true;
9921 }
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9925
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 {
9930 resultobj = wxPyMake_wxObject(result, (bool)1);
9931 }
9932 {
9933 if (temp3)
9934 delete arg3;
9935 }
9936 return resultobj;
9937 fail:
9938 {
9939 if (temp3)
9940 delete arg3;
9941 }
9942 return NULL;
9943 }
9944
9945
9946 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9947 PyObject *resultobj = NULL;
9948 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9949 wxString *arg2 = 0 ;
9950 int arg3 = (int) 0 ;
9951 wxString result;
9952 bool temp2 = false ;
9953 PyObject * obj0 = 0 ;
9954 PyObject * obj1 = 0 ;
9955 PyObject * obj2 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self",(char *) "spec",(char *) "flags", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 arg2 = wxString_in_helper(obj1);
9965 if (arg2 == NULL) SWIG_fail;
9966 temp2 = true;
9967 }
9968 if (obj2) {
9969 {
9970 arg3 = static_cast<int >(SWIG_As_int(obj2));
9971 if (SWIG_arg_fail(3)) SWIG_fail;
9972 }
9973 }
9974 {
9975 PyThreadState* __tstate = wxPyBeginAllowThreads();
9976 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9977
9978 wxPyEndAllowThreads(__tstate);
9979 if (PyErr_Occurred()) SWIG_fail;
9980 }
9981 {
9982 #if wxUSE_UNICODE
9983 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9984 #else
9985 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9986 #endif
9987 }
9988 {
9989 if (temp2)
9990 delete arg2;
9991 }
9992 return resultobj;
9993 fail:
9994 {
9995 if (temp2)
9996 delete arg2;
9997 }
9998 return NULL;
9999 }
10000
10001
10002 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
10003 PyObject *resultobj = NULL;
10004 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
10005 wxString result;
10006 PyObject * obj0 = 0 ;
10007 char *kwnames[] = {
10008 (char *) "self", NULL
10009 };
10010
10011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
10012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10013 if (SWIG_arg_fail(1)) SWIG_fail;
10014 {
10015 PyThreadState* __tstate = wxPyBeginAllowThreads();
10016 result = (arg1)->FindNext();
10017
10018 wxPyEndAllowThreads(__tstate);
10019 if (PyErr_Occurred()) SWIG_fail;
10020 }
10021 {
10022 #if wxUSE_UNICODE
10023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10024 #else
10025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10026 #endif
10027 }
10028 return resultobj;
10029 fail:
10030 return NULL;
10031 }
10032
10033
10034 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10035 PyObject *obj;
10036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10037 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10038 Py_INCREF(obj);
10039 return Py_BuildValue((char *)"");
10040 }
10041 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10042 PyObject *resultobj = NULL;
10043 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10044 wxString result;
10045 PyObject * obj0 = 0 ;
10046 char *kwnames[] = {
10047 (char *) "self", NULL
10048 };
10049
10050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10052 if (SWIG_arg_fail(1)) SWIG_fail;
10053 {
10054 PyThreadState* __tstate = wxPyBeginAllowThreads();
10055 result = (arg1)->GetName();
10056
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 {
10061 #if wxUSE_UNICODE
10062 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10063 #else
10064 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10065 #endif
10066 }
10067 return resultobj;
10068 fail:
10069 return NULL;
10070 }
10071
10072
10073 static PyObject *_wrap_ImageHandler_GetExtension(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_GetExtension",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)->GetExtension();
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_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj = NULL;
10107 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10108 long result;
10109 PyObject * obj0 = 0 ;
10110 char *kwnames[] = {
10111 (char *) "self", NULL
10112 };
10113
10114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",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 = (long)(arg1)->GetType();
10120
10121 wxPyEndAllowThreads(__tstate);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 {
10125 resultobj = SWIG_From_long(static_cast<long >(result));
10126 }
10127 return resultobj;
10128 fail:
10129 return NULL;
10130 }
10131
10132
10133 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj = NULL;
10135 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10136 wxString result;
10137 PyObject * obj0 = 0 ;
10138 char *kwnames[] = {
10139 (char *) "self", NULL
10140 };
10141
10142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10144 if (SWIG_arg_fail(1)) SWIG_fail;
10145 {
10146 PyThreadState* __tstate = wxPyBeginAllowThreads();
10147 result = (arg1)->GetMimeType();
10148
10149 wxPyEndAllowThreads(__tstate);
10150 if (PyErr_Occurred()) SWIG_fail;
10151 }
10152 {
10153 #if wxUSE_UNICODE
10154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10155 #else
10156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10157 #endif
10158 }
10159 return resultobj;
10160 fail:
10161 return NULL;
10162 }
10163
10164
10165 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10166 PyObject *resultobj = NULL;
10167 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10168 wxString *arg2 = 0 ;
10169 bool result;
10170 bool temp2 = false ;
10171 PyObject * obj0 = 0 ;
10172 PyObject * obj1 = 0 ;
10173 char *kwnames[] = {
10174 (char *) "self",(char *) "name", NULL
10175 };
10176
10177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10179 if (SWIG_arg_fail(1)) SWIG_fail;
10180 {
10181 arg2 = wxString_in_helper(obj1);
10182 if (arg2 == NULL) SWIG_fail;
10183 temp2 = true;
10184 }
10185 {
10186 PyThreadState* __tstate = wxPyBeginAllowThreads();
10187 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10188
10189 wxPyEndAllowThreads(__tstate);
10190 if (PyErr_Occurred()) SWIG_fail;
10191 }
10192 {
10193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10194 }
10195 {
10196 if (temp2)
10197 delete arg2;
10198 }
10199 return resultobj;
10200 fail:
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return NULL;
10206 }
10207
10208
10209 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10210 PyObject *resultobj = NULL;
10211 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10212 wxString *arg2 = 0 ;
10213 bool temp2 = false ;
10214 PyObject * obj0 = 0 ;
10215 PyObject * obj1 = 0 ;
10216 char *kwnames[] = {
10217 (char *) "self",(char *) "name", NULL
10218 };
10219
10220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10222 if (SWIG_arg_fail(1)) SWIG_fail;
10223 {
10224 arg2 = wxString_in_helper(obj1);
10225 if (arg2 == NULL) SWIG_fail;
10226 temp2 = true;
10227 }
10228 {
10229 PyThreadState* __tstate = wxPyBeginAllowThreads();
10230 (arg1)->SetName((wxString const &)*arg2);
10231
10232 wxPyEndAllowThreads(__tstate);
10233 if (PyErr_Occurred()) SWIG_fail;
10234 }
10235 Py_INCREF(Py_None); resultobj = Py_None;
10236 {
10237 if (temp2)
10238 delete arg2;
10239 }
10240 return resultobj;
10241 fail:
10242 {
10243 if (temp2)
10244 delete arg2;
10245 }
10246 return NULL;
10247 }
10248
10249
10250 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = NULL;
10252 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10253 wxString *arg2 = 0 ;
10254 bool temp2 = false ;
10255 PyObject * obj0 = 0 ;
10256 PyObject * obj1 = 0 ;
10257 char *kwnames[] = {
10258 (char *) "self",(char *) "extension", NULL
10259 };
10260
10261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10263 if (SWIG_arg_fail(1)) SWIG_fail;
10264 {
10265 arg2 = wxString_in_helper(obj1);
10266 if (arg2 == NULL) SWIG_fail;
10267 temp2 = true;
10268 }
10269 {
10270 PyThreadState* __tstate = wxPyBeginAllowThreads();
10271 (arg1)->SetExtension((wxString const &)*arg2);
10272
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 Py_INCREF(Py_None); resultobj = Py_None;
10277 {
10278 if (temp2)
10279 delete arg2;
10280 }
10281 return resultobj;
10282 fail:
10283 {
10284 if (temp2)
10285 delete arg2;
10286 }
10287 return NULL;
10288 }
10289
10290
10291 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10292 PyObject *resultobj = NULL;
10293 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10294 long arg2 ;
10295 PyObject * obj0 = 0 ;
10296 PyObject * obj1 = 0 ;
10297 char *kwnames[] = {
10298 (char *) "self",(char *) "type", NULL
10299 };
10300
10301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10303 if (SWIG_arg_fail(1)) SWIG_fail;
10304 {
10305 arg2 = static_cast<long >(SWIG_As_long(obj1));
10306 if (SWIG_arg_fail(2)) SWIG_fail;
10307 }
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 (arg1)->SetType(arg2);
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 Py_INCREF(Py_None); resultobj = Py_None;
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10323 PyObject *resultobj = NULL;
10324 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10325 wxString *arg2 = 0 ;
10326 bool temp2 = false ;
10327 PyObject * obj0 = 0 ;
10328 PyObject * obj1 = 0 ;
10329 char *kwnames[] = {
10330 (char *) "self",(char *) "mimetype", NULL
10331 };
10332
10333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",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 = wxString_in_helper(obj1);
10338 if (arg2 == NULL) SWIG_fail;
10339 temp2 = true;
10340 }
10341 {
10342 PyThreadState* __tstate = wxPyBeginAllowThreads();
10343 (arg1)->SetMimeType((wxString const &)*arg2);
10344
10345 wxPyEndAllowThreads(__tstate);
10346 if (PyErr_Occurred()) SWIG_fail;
10347 }
10348 Py_INCREF(Py_None); resultobj = Py_None;
10349 {
10350 if (temp2)
10351 delete arg2;
10352 }
10353 return resultobj;
10354 fail:
10355 {
10356 if (temp2)
10357 delete arg2;
10358 }
10359 return NULL;
10360 }
10361
10362
10363 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10364 PyObject *obj;
10365 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10366 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10367 Py_INCREF(obj);
10368 return Py_BuildValue((char *)"");
10369 }
10370 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10371 PyObject *resultobj = NULL;
10372 wxPyImageHandler *result;
10373 char *kwnames[] = {
10374 NULL
10375 };
10376
10377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (wxPyImageHandler *)new wxPyImageHandler();
10381
10382 wxPyEndAllowThreads(__tstate);
10383 if (PyErr_Occurred()) SWIG_fail;
10384 }
10385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10386 return resultobj;
10387 fail:
10388 return NULL;
10389 }
10390
10391
10392 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10393 PyObject *resultobj = NULL;
10394 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10395 PyObject *arg2 = (PyObject *) 0 ;
10396 PyObject * obj0 = 0 ;
10397 PyObject * obj1 = 0 ;
10398 char *kwnames[] = {
10399 (char *) "self",(char *) "self", NULL
10400 };
10401
10402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10404 if (SWIG_arg_fail(1)) SWIG_fail;
10405 arg2 = obj1;
10406 {
10407 PyThreadState* __tstate = wxPyBeginAllowThreads();
10408 (arg1)->_SetSelf(arg2);
10409
10410 wxPyEndAllowThreads(__tstate);
10411 if (PyErr_Occurred()) SWIG_fail;
10412 }
10413 Py_INCREF(Py_None); resultobj = Py_None;
10414 return resultobj;
10415 fail:
10416 return NULL;
10417 }
10418
10419
10420 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10421 PyObject *obj;
10422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10423 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10424 Py_INCREF(obj);
10425 return Py_BuildValue((char *)"");
10426 }
10427 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10428 PyObject *resultobj = NULL;
10429 wxImageHistogram *result;
10430 char *kwnames[] = {
10431 NULL
10432 };
10433
10434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10435 {
10436 PyThreadState* __tstate = wxPyBeginAllowThreads();
10437 result = (wxImageHistogram *)new wxImageHistogram();
10438
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10443 return resultobj;
10444 fail:
10445 return NULL;
10446 }
10447
10448
10449 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10450 PyObject *resultobj = NULL;
10451 byte arg1 ;
10452 byte arg2 ;
10453 byte arg3 ;
10454 unsigned long result;
10455 PyObject * obj0 = 0 ;
10456 PyObject * obj1 = 0 ;
10457 PyObject * obj2 = 0 ;
10458 char *kwnames[] = {
10459 (char *) "r",(char *) "g",(char *) "b", NULL
10460 };
10461
10462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10463 {
10464 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10465 if (SWIG_arg_fail(1)) SWIG_fail;
10466 }
10467 {
10468 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10469 if (SWIG_arg_fail(2)) SWIG_fail;
10470 }
10471 {
10472 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10473 if (SWIG_arg_fail(3)) SWIG_fail;
10474 }
10475 {
10476 PyThreadState* __tstate = wxPyBeginAllowThreads();
10477 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10478
10479 wxPyEndAllowThreads(__tstate);
10480 if (PyErr_Occurred()) SWIG_fail;
10481 }
10482 {
10483 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10484 }
10485 return resultobj;
10486 fail:
10487 return NULL;
10488 }
10489
10490
10491 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10492 PyObject *resultobj = NULL;
10493 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10494 byte *arg2 = (byte *) 0 ;
10495 byte *arg3 = (byte *) 0 ;
10496 byte *arg4 = (byte *) 0 ;
10497 byte arg5 = (byte) 1 ;
10498 byte arg6 = (byte) 0 ;
10499 byte arg7 = (byte) 0 ;
10500 bool result;
10501 byte temp2 ;
10502 int res2 = 0 ;
10503 byte temp3 ;
10504 int res3 = 0 ;
10505 byte temp4 ;
10506 int res4 = 0 ;
10507 PyObject * obj0 = 0 ;
10508 PyObject * obj1 = 0 ;
10509 PyObject * obj2 = 0 ;
10510 PyObject * obj3 = 0 ;
10511 char *kwnames[] = {
10512 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10513 };
10514
10515 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10516 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10517 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10520 if (SWIG_arg_fail(1)) SWIG_fail;
10521 if (obj1) {
10522 {
10523 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10524 if (SWIG_arg_fail(5)) SWIG_fail;
10525 }
10526 }
10527 if (obj2) {
10528 {
10529 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10530 if (SWIG_arg_fail(6)) SWIG_fail;
10531 }
10532 }
10533 if (obj3) {
10534 {
10535 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10536 if (SWIG_arg_fail(7)) SWIG_fail;
10537 }
10538 }
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10542
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 {
10547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10548 }
10549 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10550 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10551 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10552 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10553 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10554 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10555 return resultobj;
10556 fail:
10557 return NULL;
10558 }
10559
10560
10561 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10562 PyObject *resultobj = NULL;
10563 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10564 unsigned long arg2 ;
10565 unsigned long result;
10566 PyObject * obj0 = 0 ;
10567 PyObject * obj1 = 0 ;
10568 char *kwnames[] = {
10569 (char *) "self",(char *) "key", NULL
10570 };
10571
10572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10574 if (SWIG_arg_fail(1)) SWIG_fail;
10575 {
10576 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10577 if (SWIG_arg_fail(2)) SWIG_fail;
10578 }
10579 {
10580 PyThreadState* __tstate = wxPyBeginAllowThreads();
10581 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10582
10583 wxPyEndAllowThreads(__tstate);
10584 if (PyErr_Occurred()) SWIG_fail;
10585 }
10586 {
10587 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10588 }
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10596 PyObject *resultobj = NULL;
10597 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10598 byte arg2 ;
10599 byte arg3 ;
10600 byte arg4 ;
10601 unsigned long result;
10602 PyObject * obj0 = 0 ;
10603 PyObject * obj1 = 0 ;
10604 PyObject * obj2 = 0 ;
10605 PyObject * obj3 = 0 ;
10606 char *kwnames[] = {
10607 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10608 };
10609
10610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10612 if (SWIG_arg_fail(1)) SWIG_fail;
10613 {
10614 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10615 if (SWIG_arg_fail(2)) SWIG_fail;
10616 }
10617 {
10618 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10619 if (SWIG_arg_fail(3)) SWIG_fail;
10620 }
10621 {
10622 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10623 if (SWIG_arg_fail(4)) SWIG_fail;
10624 }
10625 {
10626 PyThreadState* __tstate = wxPyBeginAllowThreads();
10627 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10628
10629 wxPyEndAllowThreads(__tstate);
10630 if (PyErr_Occurred()) SWIG_fail;
10631 }
10632 {
10633 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10634 }
10635 return resultobj;
10636 fail:
10637 return NULL;
10638 }
10639
10640
10641 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10642 PyObject *resultobj = NULL;
10643 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10644 wxColour *arg2 = 0 ;
10645 unsigned long result;
10646 wxColour temp2 ;
10647 PyObject * obj0 = 0 ;
10648 PyObject * obj1 = 0 ;
10649 char *kwnames[] = {
10650 (char *) "self",(char *) "colour", NULL
10651 };
10652
10653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10655 if (SWIG_arg_fail(1)) SWIG_fail;
10656 {
10657 arg2 = &temp2;
10658 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10659 }
10660 {
10661 PyThreadState* __tstate = wxPyBeginAllowThreads();
10662 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10663
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 {
10668 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10669 }
10670 return resultobj;
10671 fail:
10672 return NULL;
10673 }
10674
10675
10676 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10677 PyObject *obj;
10678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10679 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10680 Py_INCREF(obj);
10681 return Py_BuildValue((char *)"");
10682 }
10683 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10684 PyObject *resultobj = NULL;
10685 byte arg1 = (byte) 0 ;
10686 byte arg2 = (byte) 0 ;
10687 byte arg3 = (byte) 0 ;
10688 wxImage_RGBValue *result;
10689 PyObject * obj0 = 0 ;
10690 PyObject * obj1 = 0 ;
10691 PyObject * obj2 = 0 ;
10692 char *kwnames[] = {
10693 (char *) "r",(char *) "g",(char *) "b", NULL
10694 };
10695
10696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10697 if (obj0) {
10698 {
10699 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10700 if (SWIG_arg_fail(1)) SWIG_fail;
10701 }
10702 }
10703 if (obj1) {
10704 {
10705 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10706 if (SWIG_arg_fail(2)) SWIG_fail;
10707 }
10708 }
10709 if (obj2) {
10710 {
10711 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10712 if (SWIG_arg_fail(3)) SWIG_fail;
10713 }
10714 }
10715 {
10716 PyThreadState* __tstate = wxPyBeginAllowThreads();
10717 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10718
10719 wxPyEndAllowThreads(__tstate);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10723 return resultobj;
10724 fail:
10725 return NULL;
10726 }
10727
10728
10729 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj = NULL;
10731 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10732 byte arg2 ;
10733 PyObject * obj0 = 0 ;
10734 PyObject * obj1 = 0 ;
10735 char *kwnames[] = {
10736 (char *) "self",(char *) "red", NULL
10737 };
10738
10739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10741 if (SWIG_arg_fail(1)) SWIG_fail;
10742 {
10743 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10744 if (SWIG_arg_fail(2)) SWIG_fail;
10745 }
10746 if (arg1) (arg1)->red = arg2;
10747
10748 Py_INCREF(Py_None); resultobj = Py_None;
10749 return resultobj;
10750 fail:
10751 return NULL;
10752 }
10753
10754
10755 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10756 PyObject *resultobj = NULL;
10757 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10758 byte result;
10759 PyObject * obj0 = 0 ;
10760 char *kwnames[] = {
10761 (char *) "self", NULL
10762 };
10763
10764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10766 if (SWIG_arg_fail(1)) SWIG_fail;
10767 result = (byte) ((arg1)->red);
10768
10769 {
10770 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10771 }
10772 return resultobj;
10773 fail:
10774 return NULL;
10775 }
10776
10777
10778 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10779 PyObject *resultobj = NULL;
10780 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10781 byte arg2 ;
10782 PyObject * obj0 = 0 ;
10783 PyObject * obj1 = 0 ;
10784 char *kwnames[] = {
10785 (char *) "self",(char *) "green", NULL
10786 };
10787
10788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10790 if (SWIG_arg_fail(1)) SWIG_fail;
10791 {
10792 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10793 if (SWIG_arg_fail(2)) SWIG_fail;
10794 }
10795 if (arg1) (arg1)->green = arg2;
10796
10797 Py_INCREF(Py_None); resultobj = Py_None;
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj = NULL;
10806 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10807 byte result;
10808 PyObject * obj0 = 0 ;
10809 char *kwnames[] = {
10810 (char *) "self", NULL
10811 };
10812
10813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10815 if (SWIG_arg_fail(1)) SWIG_fail;
10816 result = (byte) ((arg1)->green);
10817
10818 {
10819 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10820 }
10821 return resultobj;
10822 fail:
10823 return NULL;
10824 }
10825
10826
10827 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10828 PyObject *resultobj = NULL;
10829 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10830 byte arg2 ;
10831 PyObject * obj0 = 0 ;
10832 PyObject * obj1 = 0 ;
10833 char *kwnames[] = {
10834 (char *) "self",(char *) "blue", NULL
10835 };
10836
10837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10839 if (SWIG_arg_fail(1)) SWIG_fail;
10840 {
10841 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10842 if (SWIG_arg_fail(2)) SWIG_fail;
10843 }
10844 if (arg1) (arg1)->blue = arg2;
10845
10846 Py_INCREF(Py_None); resultobj = Py_None;
10847 return resultobj;
10848 fail:
10849 return NULL;
10850 }
10851
10852
10853 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10854 PyObject *resultobj = NULL;
10855 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10856 byte result;
10857 PyObject * obj0 = 0 ;
10858 char *kwnames[] = {
10859 (char *) "self", NULL
10860 };
10861
10862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10864 if (SWIG_arg_fail(1)) SWIG_fail;
10865 result = (byte) ((arg1)->blue);
10866
10867 {
10868 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10869 }
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10877 PyObject *obj;
10878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10879 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10880 Py_INCREF(obj);
10881 return Py_BuildValue((char *)"");
10882 }
10883 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10884 PyObject *resultobj = NULL;
10885 double arg1 = (double) 0.0 ;
10886 double arg2 = (double) 0.0 ;
10887 double arg3 = (double) 0.0 ;
10888 wxImage_HSVValue *result;
10889 PyObject * obj0 = 0 ;
10890 PyObject * obj1 = 0 ;
10891 PyObject * obj2 = 0 ;
10892 char *kwnames[] = {
10893 (char *) "h",(char *) "s",(char *) "v", NULL
10894 };
10895
10896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10897 if (obj0) {
10898 {
10899 arg1 = static_cast<double >(SWIG_As_double(obj0));
10900 if (SWIG_arg_fail(1)) SWIG_fail;
10901 }
10902 }
10903 if (obj1) {
10904 {
10905 arg2 = static_cast<double >(SWIG_As_double(obj1));
10906 if (SWIG_arg_fail(2)) SWIG_fail;
10907 }
10908 }
10909 if (obj2) {
10910 {
10911 arg3 = static_cast<double >(SWIG_As_double(obj2));
10912 if (SWIG_arg_fail(3)) SWIG_fail;
10913 }
10914 }
10915 {
10916 PyThreadState* __tstate = wxPyBeginAllowThreads();
10917 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10918
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10930 PyObject *resultobj = NULL;
10931 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10932 double arg2 ;
10933 PyObject * obj0 = 0 ;
10934 PyObject * obj1 = 0 ;
10935 char *kwnames[] = {
10936 (char *) "self",(char *) "hue", NULL
10937 };
10938
10939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10941 if (SWIG_arg_fail(1)) SWIG_fail;
10942 {
10943 arg2 = static_cast<double >(SWIG_As_double(obj1));
10944 if (SWIG_arg_fail(2)) SWIG_fail;
10945 }
10946 if (arg1) (arg1)->hue = arg2;
10947
10948 Py_INCREF(Py_None); resultobj = Py_None;
10949 return resultobj;
10950 fail:
10951 return NULL;
10952 }
10953
10954
10955 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10956 PyObject *resultobj = NULL;
10957 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10958 double result;
10959 PyObject * obj0 = 0 ;
10960 char *kwnames[] = {
10961 (char *) "self", NULL
10962 };
10963
10964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10966 if (SWIG_arg_fail(1)) SWIG_fail;
10967 result = (double) ((arg1)->hue);
10968
10969 {
10970 resultobj = SWIG_From_double(static_cast<double >(result));
10971 }
10972 return resultobj;
10973 fail:
10974 return NULL;
10975 }
10976
10977
10978 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10979 PyObject *resultobj = NULL;
10980 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10981 double arg2 ;
10982 PyObject * obj0 = 0 ;
10983 PyObject * obj1 = 0 ;
10984 char *kwnames[] = {
10985 (char *) "self",(char *) "saturation", NULL
10986 };
10987
10988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10990 if (SWIG_arg_fail(1)) SWIG_fail;
10991 {
10992 arg2 = static_cast<double >(SWIG_As_double(obj1));
10993 if (SWIG_arg_fail(2)) SWIG_fail;
10994 }
10995 if (arg1) (arg1)->saturation = arg2;
10996
10997 Py_INCREF(Py_None); resultobj = Py_None;
10998 return resultobj;
10999 fail:
11000 return NULL;
11001 }
11002
11003
11004 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
11005 PyObject *resultobj = NULL;
11006 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11007 double result;
11008 PyObject * obj0 = 0 ;
11009 char *kwnames[] = {
11010 (char *) "self", NULL
11011 };
11012
11013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
11014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11015 if (SWIG_arg_fail(1)) SWIG_fail;
11016 result = (double) ((arg1)->saturation);
11017
11018 {
11019 resultobj = SWIG_From_double(static_cast<double >(result));
11020 }
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11028 PyObject *resultobj = NULL;
11029 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11030 double arg2 ;
11031 PyObject * obj0 = 0 ;
11032 PyObject * obj1 = 0 ;
11033 char *kwnames[] = {
11034 (char *) "self",(char *) "value", NULL
11035 };
11036
11037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11039 if (SWIG_arg_fail(1)) SWIG_fail;
11040 {
11041 arg2 = static_cast<double >(SWIG_As_double(obj1));
11042 if (SWIG_arg_fail(2)) SWIG_fail;
11043 }
11044 if (arg1) (arg1)->value = arg2;
11045
11046 Py_INCREF(Py_None); resultobj = Py_None;
11047 return resultobj;
11048 fail:
11049 return NULL;
11050 }
11051
11052
11053 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11054 PyObject *resultobj = NULL;
11055 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11056 double result;
11057 PyObject * obj0 = 0 ;
11058 char *kwnames[] = {
11059 (char *) "self", NULL
11060 };
11061
11062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11064 if (SWIG_arg_fail(1)) SWIG_fail;
11065 result = (double) ((arg1)->value);
11066
11067 {
11068 resultobj = SWIG_From_double(static_cast<double >(result));
11069 }
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11077 PyObject *obj;
11078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11079 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11080 Py_INCREF(obj);
11081 return Py_BuildValue((char *)"");
11082 }
11083 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11084 PyObject *resultobj = NULL;
11085 wxString *arg1 = 0 ;
11086 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11087 int arg3 = (int) -1 ;
11088 wxImage *result;
11089 bool temp1 = false ;
11090 PyObject * obj0 = 0 ;
11091 PyObject * obj1 = 0 ;
11092 PyObject * obj2 = 0 ;
11093 char *kwnames[] = {
11094 (char *) "name",(char *) "type",(char *) "index", NULL
11095 };
11096
11097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11098 {
11099 arg1 = wxString_in_helper(obj0);
11100 if (arg1 == NULL) SWIG_fail;
11101 temp1 = true;
11102 }
11103 if (obj1) {
11104 {
11105 arg2 = static_cast<long >(SWIG_As_long(obj1));
11106 if (SWIG_arg_fail(2)) SWIG_fail;
11107 }
11108 }
11109 if (obj2) {
11110 {
11111 arg3 = static_cast<int >(SWIG_As_int(obj2));
11112 if (SWIG_arg_fail(3)) SWIG_fail;
11113 }
11114 }
11115 {
11116 PyThreadState* __tstate = wxPyBeginAllowThreads();
11117 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11118
11119 wxPyEndAllowThreads(__tstate);
11120 if (PyErr_Occurred()) SWIG_fail;
11121 }
11122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11123 {
11124 if (temp1)
11125 delete arg1;
11126 }
11127 return resultobj;
11128 fail:
11129 {
11130 if (temp1)
11131 delete arg1;
11132 }
11133 return NULL;
11134 }
11135
11136
11137 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11138 PyObject *resultobj = NULL;
11139 wxImage *arg1 = (wxImage *) 0 ;
11140 PyObject * obj0 = 0 ;
11141 char *kwnames[] = {
11142 (char *) "self", NULL
11143 };
11144
11145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11147 if (SWIG_arg_fail(1)) SWIG_fail;
11148 {
11149 PyThreadState* __tstate = wxPyBeginAllowThreads();
11150 delete arg1;
11151
11152 wxPyEndAllowThreads(__tstate);
11153 if (PyErr_Occurred()) SWIG_fail;
11154 }
11155 Py_INCREF(Py_None); resultobj = Py_None;
11156 return resultobj;
11157 fail:
11158 return NULL;
11159 }
11160
11161
11162 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11163 PyObject *resultobj = NULL;
11164 wxString *arg1 = 0 ;
11165 wxString *arg2 = 0 ;
11166 int arg3 = (int) -1 ;
11167 wxImage *result;
11168 bool temp1 = false ;
11169 bool temp2 = false ;
11170 PyObject * obj0 = 0 ;
11171 PyObject * obj1 = 0 ;
11172 PyObject * obj2 = 0 ;
11173 char *kwnames[] = {
11174 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11175 };
11176
11177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11178 {
11179 arg1 = wxString_in_helper(obj0);
11180 if (arg1 == NULL) SWIG_fail;
11181 temp1 = true;
11182 }
11183 {
11184 arg2 = wxString_in_helper(obj1);
11185 if (arg2 == NULL) SWIG_fail;
11186 temp2 = true;
11187 }
11188 if (obj2) {
11189 {
11190 arg3 = static_cast<int >(SWIG_As_int(obj2));
11191 if (SWIG_arg_fail(3)) SWIG_fail;
11192 }
11193 }
11194 {
11195 PyThreadState* __tstate = wxPyBeginAllowThreads();
11196 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11197
11198 wxPyEndAllowThreads(__tstate);
11199 if (PyErr_Occurred()) SWIG_fail;
11200 }
11201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11202 {
11203 if (temp1)
11204 delete arg1;
11205 }
11206 {
11207 if (temp2)
11208 delete arg2;
11209 }
11210 return resultobj;
11211 fail:
11212 {
11213 if (temp1)
11214 delete arg1;
11215 }
11216 {
11217 if (temp2)
11218 delete arg2;
11219 }
11220 return NULL;
11221 }
11222
11223
11224 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11225 PyObject *resultobj = NULL;
11226 wxInputStream *arg1 = 0 ;
11227 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11228 int arg3 = (int) -1 ;
11229 wxImage *result;
11230 wxPyInputStream *temp1 ;
11231 bool created1 ;
11232 PyObject * obj0 = 0 ;
11233 PyObject * obj1 = 0 ;
11234 PyObject * obj2 = 0 ;
11235 char *kwnames[] = {
11236 (char *) "stream",(char *) "type",(char *) "index", NULL
11237 };
11238
11239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11240 {
11241 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11242 arg1 = temp1->m_wxis;
11243 created1 = false;
11244 } else {
11245 PyErr_Clear(); // clear the failure of the wxPyConvert above
11246 arg1 = wxPyCBInputStream_create(obj0, false);
11247 if (arg1 == NULL) {
11248 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11249 SWIG_fail;
11250 }
11251 created1 = true;
11252 }
11253 }
11254 if (obj1) {
11255 {
11256 arg2 = static_cast<long >(SWIG_As_long(obj1));
11257 if (SWIG_arg_fail(2)) SWIG_fail;
11258 }
11259 }
11260 if (obj2) {
11261 {
11262 arg3 = static_cast<int >(SWIG_As_int(obj2));
11263 if (SWIG_arg_fail(3)) SWIG_fail;
11264 }
11265 }
11266 {
11267 PyThreadState* __tstate = wxPyBeginAllowThreads();
11268 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11269
11270 wxPyEndAllowThreads(__tstate);
11271 if (PyErr_Occurred()) SWIG_fail;
11272 }
11273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11274 {
11275 if (created1) delete arg1;
11276 }
11277 return resultobj;
11278 fail:
11279 {
11280 if (created1) delete arg1;
11281 }
11282 return NULL;
11283 }
11284
11285
11286 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11287 PyObject *resultobj = NULL;
11288 wxInputStream *arg1 = 0 ;
11289 wxString *arg2 = 0 ;
11290 int arg3 = (int) -1 ;
11291 wxImage *result;
11292 wxPyInputStream *temp1 ;
11293 bool created1 ;
11294 bool temp2 = false ;
11295 PyObject * obj0 = 0 ;
11296 PyObject * obj1 = 0 ;
11297 PyObject * obj2 = 0 ;
11298 char *kwnames[] = {
11299 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11300 };
11301
11302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11303 {
11304 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11305 arg1 = temp1->m_wxis;
11306 created1 = false;
11307 } else {
11308 PyErr_Clear(); // clear the failure of the wxPyConvert above
11309 arg1 = wxPyCBInputStream_create(obj0, false);
11310 if (arg1 == NULL) {
11311 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11312 SWIG_fail;
11313 }
11314 created1 = true;
11315 }
11316 }
11317 {
11318 arg2 = wxString_in_helper(obj1);
11319 if (arg2 == NULL) SWIG_fail;
11320 temp2 = true;
11321 }
11322 if (obj2) {
11323 {
11324 arg3 = static_cast<int >(SWIG_As_int(obj2));
11325 if (SWIG_arg_fail(3)) SWIG_fail;
11326 }
11327 }
11328 {
11329 PyThreadState* __tstate = wxPyBeginAllowThreads();
11330 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11331
11332 wxPyEndAllowThreads(__tstate);
11333 if (PyErr_Occurred()) SWIG_fail;
11334 }
11335 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11336 {
11337 if (created1) delete arg1;
11338 }
11339 {
11340 if (temp2)
11341 delete arg2;
11342 }
11343 return resultobj;
11344 fail:
11345 {
11346 if (created1) delete arg1;
11347 }
11348 {
11349 if (temp2)
11350 delete arg2;
11351 }
11352 return NULL;
11353 }
11354
11355
11356 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = NULL;
11358 int arg1 = (int) 0 ;
11359 int arg2 = (int) 0 ;
11360 bool arg3 = (bool) true ;
11361 wxImage *result;
11362 PyObject * obj0 = 0 ;
11363 PyObject * obj1 = 0 ;
11364 PyObject * obj2 = 0 ;
11365 char *kwnames[] = {
11366 (char *) "width",(char *) "height",(char *) "clear", NULL
11367 };
11368
11369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11370 if (obj0) {
11371 {
11372 arg1 = static_cast<int >(SWIG_As_int(obj0));
11373 if (SWIG_arg_fail(1)) SWIG_fail;
11374 }
11375 }
11376 if (obj1) {
11377 {
11378 arg2 = static_cast<int >(SWIG_As_int(obj1));
11379 if (SWIG_arg_fail(2)) SWIG_fail;
11380 }
11381 }
11382 if (obj2) {
11383 {
11384 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11385 if (SWIG_arg_fail(3)) SWIG_fail;
11386 }
11387 }
11388 {
11389 PyThreadState* __tstate = wxPyBeginAllowThreads();
11390 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11391
11392 wxPyEndAllowThreads(__tstate);
11393 if (PyErr_Occurred()) SWIG_fail;
11394 }
11395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11396 return resultobj;
11397 fail:
11398 return NULL;
11399 }
11400
11401
11402 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11403 PyObject *resultobj = NULL;
11404 wxBitmap *arg1 = 0 ;
11405 wxImage *result;
11406 PyObject * obj0 = 0 ;
11407 char *kwnames[] = {
11408 (char *) "bitmap", NULL
11409 };
11410
11411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11412 {
11413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11414 if (SWIG_arg_fail(1)) SWIG_fail;
11415 if (arg1 == NULL) {
11416 SWIG_null_ref("wxBitmap");
11417 }
11418 if (SWIG_arg_fail(1)) SWIG_fail;
11419 }
11420 {
11421 if (!wxPyCheckForApp()) SWIG_fail;
11422 PyThreadState* __tstate = wxPyBeginAllowThreads();
11423 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11424
11425 wxPyEndAllowThreads(__tstate);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11436 PyObject *resultobj = NULL;
11437 int arg1 ;
11438 int arg2 ;
11439 buffer arg3 ;
11440 int arg4 ;
11441 wxImage *result;
11442 PyObject * obj0 = 0 ;
11443 PyObject * obj1 = 0 ;
11444 PyObject * obj2 = 0 ;
11445 char *kwnames[] = {
11446 (char *) "width",(char *) "height",(char *) "data", NULL
11447 };
11448
11449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11450 {
11451 arg1 = static_cast<int >(SWIG_As_int(obj0));
11452 if (SWIG_arg_fail(1)) SWIG_fail;
11453 }
11454 {
11455 arg2 = static_cast<int >(SWIG_As_int(obj1));
11456 if (SWIG_arg_fail(2)) SWIG_fail;
11457 }
11458 {
11459 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11460 }
11461 {
11462 PyThreadState* __tstate = wxPyBeginAllowThreads();
11463 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11464
11465 wxPyEndAllowThreads(__tstate);
11466 if (PyErr_Occurred()) SWIG_fail;
11467 }
11468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11469 return resultobj;
11470 fail:
11471 return NULL;
11472 }
11473
11474
11475 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11476 PyObject *resultobj = NULL;
11477 int arg1 ;
11478 int arg2 ;
11479 buffer arg3 ;
11480 int arg4 ;
11481 buffer arg5 ;
11482 int arg6 ;
11483 wxImage *result;
11484 PyObject * obj0 = 0 ;
11485 PyObject * obj1 = 0 ;
11486 PyObject * obj2 = 0 ;
11487 PyObject * obj3 = 0 ;
11488 char *kwnames[] = {
11489 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11490 };
11491
11492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11493 {
11494 arg1 = static_cast<int >(SWIG_As_int(obj0));
11495 if (SWIG_arg_fail(1)) SWIG_fail;
11496 }
11497 {
11498 arg2 = static_cast<int >(SWIG_As_int(obj1));
11499 if (SWIG_arg_fail(2)) SWIG_fail;
11500 }
11501 {
11502 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11503 }
11504 {
11505 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11506 }
11507 {
11508 PyThreadState* __tstate = wxPyBeginAllowThreads();
11509 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11510
11511 wxPyEndAllowThreads(__tstate);
11512 if (PyErr_Occurred()) SWIG_fail;
11513 }
11514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11515 return resultobj;
11516 fail:
11517 return NULL;
11518 }
11519
11520
11521 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11522 PyObject *resultobj = NULL;
11523 wxImage *arg1 = (wxImage *) 0 ;
11524 int arg2 ;
11525 int arg3 ;
11526 bool arg4 = (bool) true ;
11527 PyObject * obj0 = 0 ;
11528 PyObject * obj1 = 0 ;
11529 PyObject * obj2 = 0 ;
11530 PyObject * obj3 = 0 ;
11531 char *kwnames[] = {
11532 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11533 };
11534
11535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11537 if (SWIG_arg_fail(1)) SWIG_fail;
11538 {
11539 arg2 = static_cast<int >(SWIG_As_int(obj1));
11540 if (SWIG_arg_fail(2)) SWIG_fail;
11541 }
11542 {
11543 arg3 = static_cast<int >(SWIG_As_int(obj2));
11544 if (SWIG_arg_fail(3)) SWIG_fail;
11545 }
11546 if (obj3) {
11547 {
11548 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11549 if (SWIG_arg_fail(4)) SWIG_fail;
11550 }
11551 }
11552 {
11553 PyThreadState* __tstate = wxPyBeginAllowThreads();
11554 (arg1)->Create(arg2,arg3,arg4);
11555
11556 wxPyEndAllowThreads(__tstate);
11557 if (PyErr_Occurred()) SWIG_fail;
11558 }
11559 Py_INCREF(Py_None); resultobj = Py_None;
11560 return resultobj;
11561 fail:
11562 return NULL;
11563 }
11564
11565
11566 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11567 PyObject *resultobj = NULL;
11568 wxImage *arg1 = (wxImage *) 0 ;
11569 PyObject * obj0 = 0 ;
11570 char *kwnames[] = {
11571 (char *) "self", NULL
11572 };
11573
11574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11576 if (SWIG_arg_fail(1)) SWIG_fail;
11577 {
11578 PyThreadState* __tstate = wxPyBeginAllowThreads();
11579 (arg1)->Destroy();
11580
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 Py_INCREF(Py_None); resultobj = Py_None;
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj = NULL;
11593 wxImage *arg1 = (wxImage *) 0 ;
11594 int arg2 ;
11595 int arg3 ;
11596 SwigValueWrapper<wxImage > result;
11597 PyObject * obj0 = 0 ;
11598 PyObject * obj1 = 0 ;
11599 PyObject * obj2 = 0 ;
11600 char *kwnames[] = {
11601 (char *) "self",(char *) "width",(char *) "height", NULL
11602 };
11603
11604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11606 if (SWIG_arg_fail(1)) SWIG_fail;
11607 {
11608 arg2 = static_cast<int >(SWIG_As_int(obj1));
11609 if (SWIG_arg_fail(2)) SWIG_fail;
11610 }
11611 {
11612 arg3 = static_cast<int >(SWIG_As_int(obj2));
11613 if (SWIG_arg_fail(3)) SWIG_fail;
11614 }
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 result = (arg1)->Scale(arg2,arg3);
11618
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 {
11623 wxImage * resultptr;
11624 resultptr = new wxImage(static_cast<wxImage & >(result));
11625 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11626 }
11627 return resultobj;
11628 fail:
11629 return NULL;
11630 }
11631
11632
11633 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11634 PyObject *resultobj = NULL;
11635 wxImage *arg1 = (wxImage *) 0 ;
11636 int arg2 ;
11637 int arg3 ;
11638 SwigValueWrapper<wxImage > result;
11639 PyObject * obj0 = 0 ;
11640 PyObject * obj1 = 0 ;
11641 PyObject * obj2 = 0 ;
11642 char *kwnames[] = {
11643 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11644 };
11645
11646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11648 if (SWIG_arg_fail(1)) SWIG_fail;
11649 {
11650 arg2 = static_cast<int >(SWIG_As_int(obj1));
11651 if (SWIG_arg_fail(2)) SWIG_fail;
11652 }
11653 {
11654 arg3 = static_cast<int >(SWIG_As_int(obj2));
11655 if (SWIG_arg_fail(3)) SWIG_fail;
11656 }
11657 {
11658 PyThreadState* __tstate = wxPyBeginAllowThreads();
11659 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11660
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 {
11665 wxImage * resultptr;
11666 resultptr = new wxImage(static_cast<wxImage & >(result));
11667 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11668 }
11669 return resultobj;
11670 fail:
11671 return NULL;
11672 }
11673
11674
11675 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11676 PyObject *resultobj = NULL;
11677 wxImage *arg1 = (wxImage *) 0 ;
11678 int arg2 ;
11679 int arg3 ;
11680 wxImage *result;
11681 PyObject * obj0 = 0 ;
11682 PyObject * obj1 = 0 ;
11683 PyObject * obj2 = 0 ;
11684 char *kwnames[] = {
11685 (char *) "self",(char *) "width",(char *) "height", NULL
11686 };
11687
11688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11690 if (SWIG_arg_fail(1)) SWIG_fail;
11691 {
11692 arg2 = static_cast<int >(SWIG_As_int(obj1));
11693 if (SWIG_arg_fail(2)) SWIG_fail;
11694 }
11695 {
11696 arg3 = static_cast<int >(SWIG_As_int(obj2));
11697 if (SWIG_arg_fail(3)) SWIG_fail;
11698 }
11699 {
11700 PyThreadState* __tstate = wxPyBeginAllowThreads();
11701 {
11702 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11703 result = (wxImage *) &_result_ref;
11704 }
11705
11706 wxPyEndAllowThreads(__tstate);
11707 if (PyErr_Occurred()) SWIG_fail;
11708 }
11709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11717 PyObject *resultobj = NULL;
11718 wxImage *arg1 = (wxImage *) 0 ;
11719 wxSize *arg2 = 0 ;
11720 wxPoint *arg3 = 0 ;
11721 int arg4 = (int) -1 ;
11722 int arg5 = (int) -1 ;
11723 int arg6 = (int) -1 ;
11724 wxImage *result;
11725 wxSize temp2 ;
11726 wxPoint temp3 ;
11727 PyObject * obj0 = 0 ;
11728 PyObject * obj1 = 0 ;
11729 PyObject * obj2 = 0 ;
11730 PyObject * obj3 = 0 ;
11731 PyObject * obj4 = 0 ;
11732 PyObject * obj5 = 0 ;
11733 char *kwnames[] = {
11734 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11735 };
11736
11737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11739 if (SWIG_arg_fail(1)) SWIG_fail;
11740 {
11741 arg2 = &temp2;
11742 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11743 }
11744 {
11745 arg3 = &temp3;
11746 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11747 }
11748 if (obj3) {
11749 {
11750 arg4 = static_cast<int >(SWIG_As_int(obj3));
11751 if (SWIG_arg_fail(4)) SWIG_fail;
11752 }
11753 }
11754 if (obj4) {
11755 {
11756 arg5 = static_cast<int >(SWIG_As_int(obj4));
11757 if (SWIG_arg_fail(5)) SWIG_fail;
11758 }
11759 }
11760 if (obj5) {
11761 {
11762 arg6 = static_cast<int >(SWIG_As_int(obj5));
11763 if (SWIG_arg_fail(6)) SWIG_fail;
11764 }
11765 }
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 {
11769 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11770 result = (wxImage *) &_result_ref;
11771 }
11772
11773 wxPyEndAllowThreads(__tstate);
11774 if (PyErr_Occurred()) SWIG_fail;
11775 }
11776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11777 return resultobj;
11778 fail:
11779 return NULL;
11780 }
11781
11782
11783 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11784 PyObject *resultobj = NULL;
11785 wxImage *arg1 = (wxImage *) 0 ;
11786 int arg2 ;
11787 int arg3 ;
11788 byte arg4 ;
11789 byte arg5 ;
11790 byte arg6 ;
11791 PyObject * obj0 = 0 ;
11792 PyObject * obj1 = 0 ;
11793 PyObject * obj2 = 0 ;
11794 PyObject * obj3 = 0 ;
11795 PyObject * obj4 = 0 ;
11796 PyObject * obj5 = 0 ;
11797 char *kwnames[] = {
11798 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11799 };
11800
11801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11803 if (SWIG_arg_fail(1)) SWIG_fail;
11804 {
11805 arg2 = static_cast<int >(SWIG_As_int(obj1));
11806 if (SWIG_arg_fail(2)) SWIG_fail;
11807 }
11808 {
11809 arg3 = static_cast<int >(SWIG_As_int(obj2));
11810 if (SWIG_arg_fail(3)) SWIG_fail;
11811 }
11812 {
11813 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11814 if (SWIG_arg_fail(4)) SWIG_fail;
11815 }
11816 {
11817 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11818 if (SWIG_arg_fail(5)) SWIG_fail;
11819 }
11820 {
11821 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11822 if (SWIG_arg_fail(6)) SWIG_fail;
11823 }
11824 {
11825 PyThreadState* __tstate = wxPyBeginAllowThreads();
11826 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11827
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 Py_INCREF(Py_None); resultobj = Py_None;
11832 return resultobj;
11833 fail:
11834 return NULL;
11835 }
11836
11837
11838 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11839 PyObject *resultobj = NULL;
11840 wxImage *arg1 = (wxImage *) 0 ;
11841 wxRect *arg2 = 0 ;
11842 byte arg3 ;
11843 byte arg4 ;
11844 byte arg5 ;
11845 wxRect temp2 ;
11846 PyObject * obj0 = 0 ;
11847 PyObject * obj1 = 0 ;
11848 PyObject * obj2 = 0 ;
11849 PyObject * obj3 = 0 ;
11850 PyObject * obj4 = 0 ;
11851 char *kwnames[] = {
11852 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11853 };
11854
11855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11857 if (SWIG_arg_fail(1)) SWIG_fail;
11858 {
11859 arg2 = &temp2;
11860 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11861 }
11862 {
11863 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11864 if (SWIG_arg_fail(3)) SWIG_fail;
11865 }
11866 {
11867 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11868 if (SWIG_arg_fail(4)) SWIG_fail;
11869 }
11870 {
11871 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11872 if (SWIG_arg_fail(5)) SWIG_fail;
11873 }
11874 {
11875 PyThreadState* __tstate = wxPyBeginAllowThreads();
11876 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11877
11878 wxPyEndAllowThreads(__tstate);
11879 if (PyErr_Occurred()) SWIG_fail;
11880 }
11881 Py_INCREF(Py_None); resultobj = Py_None;
11882 return resultobj;
11883 fail:
11884 return NULL;
11885 }
11886
11887
11888 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11889 PyObject *resultobj = NULL;
11890 wxImage *arg1 = (wxImage *) 0 ;
11891 int arg2 ;
11892 int arg3 ;
11893 byte result;
11894 PyObject * obj0 = 0 ;
11895 PyObject * obj1 = 0 ;
11896 PyObject * obj2 = 0 ;
11897 char *kwnames[] = {
11898 (char *) "self",(char *) "x",(char *) "y", NULL
11899 };
11900
11901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11903 if (SWIG_arg_fail(1)) SWIG_fail;
11904 {
11905 arg2 = static_cast<int >(SWIG_As_int(obj1));
11906 if (SWIG_arg_fail(2)) SWIG_fail;
11907 }
11908 {
11909 arg3 = static_cast<int >(SWIG_As_int(obj2));
11910 if (SWIG_arg_fail(3)) SWIG_fail;
11911 }
11912 {
11913 PyThreadState* __tstate = wxPyBeginAllowThreads();
11914 result = (byte)(arg1)->GetRed(arg2,arg3);
11915
11916 wxPyEndAllowThreads(__tstate);
11917 if (PyErr_Occurred()) SWIG_fail;
11918 }
11919 {
11920 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11921 }
11922 return resultobj;
11923 fail:
11924 return NULL;
11925 }
11926
11927
11928 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11929 PyObject *resultobj = NULL;
11930 wxImage *arg1 = (wxImage *) 0 ;
11931 int arg2 ;
11932 int arg3 ;
11933 byte result;
11934 PyObject * obj0 = 0 ;
11935 PyObject * obj1 = 0 ;
11936 PyObject * obj2 = 0 ;
11937 char *kwnames[] = {
11938 (char *) "self",(char *) "x",(char *) "y", NULL
11939 };
11940
11941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11943 if (SWIG_arg_fail(1)) SWIG_fail;
11944 {
11945 arg2 = static_cast<int >(SWIG_As_int(obj1));
11946 if (SWIG_arg_fail(2)) SWIG_fail;
11947 }
11948 {
11949 arg3 = static_cast<int >(SWIG_As_int(obj2));
11950 if (SWIG_arg_fail(3)) SWIG_fail;
11951 }
11952 {
11953 PyThreadState* __tstate = wxPyBeginAllowThreads();
11954 result = (byte)(arg1)->GetGreen(arg2,arg3);
11955
11956 wxPyEndAllowThreads(__tstate);
11957 if (PyErr_Occurred()) SWIG_fail;
11958 }
11959 {
11960 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11961 }
11962 return resultobj;
11963 fail:
11964 return NULL;
11965 }
11966
11967
11968 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11969 PyObject *resultobj = NULL;
11970 wxImage *arg1 = (wxImage *) 0 ;
11971 int arg2 ;
11972 int arg3 ;
11973 byte result;
11974 PyObject * obj0 = 0 ;
11975 PyObject * obj1 = 0 ;
11976 PyObject * obj2 = 0 ;
11977 char *kwnames[] = {
11978 (char *) "self",(char *) "x",(char *) "y", NULL
11979 };
11980
11981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11983 if (SWIG_arg_fail(1)) SWIG_fail;
11984 {
11985 arg2 = static_cast<int >(SWIG_As_int(obj1));
11986 if (SWIG_arg_fail(2)) SWIG_fail;
11987 }
11988 {
11989 arg3 = static_cast<int >(SWIG_As_int(obj2));
11990 if (SWIG_arg_fail(3)) SWIG_fail;
11991 }
11992 {
11993 PyThreadState* __tstate = wxPyBeginAllowThreads();
11994 result = (byte)(arg1)->GetBlue(arg2,arg3);
11995
11996 wxPyEndAllowThreads(__tstate);
11997 if (PyErr_Occurred()) SWIG_fail;
11998 }
11999 {
12000 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12001 }
12002 return resultobj;
12003 fail:
12004 return NULL;
12005 }
12006
12007
12008 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12009 PyObject *resultobj = NULL;
12010 wxImage *arg1 = (wxImage *) 0 ;
12011 int arg2 ;
12012 int arg3 ;
12013 byte arg4 ;
12014 PyObject * obj0 = 0 ;
12015 PyObject * obj1 = 0 ;
12016 PyObject * obj2 = 0 ;
12017 PyObject * obj3 = 0 ;
12018 char *kwnames[] = {
12019 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
12020 };
12021
12022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12024 if (SWIG_arg_fail(1)) SWIG_fail;
12025 {
12026 arg2 = static_cast<int >(SWIG_As_int(obj1));
12027 if (SWIG_arg_fail(2)) SWIG_fail;
12028 }
12029 {
12030 arg3 = static_cast<int >(SWIG_As_int(obj2));
12031 if (SWIG_arg_fail(3)) SWIG_fail;
12032 }
12033 {
12034 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12035 if (SWIG_arg_fail(4)) SWIG_fail;
12036 }
12037 {
12038 PyThreadState* __tstate = wxPyBeginAllowThreads();
12039 (arg1)->SetAlpha(arg2,arg3,arg4);
12040
12041 wxPyEndAllowThreads(__tstate);
12042 if (PyErr_Occurred()) SWIG_fail;
12043 }
12044 Py_INCREF(Py_None); resultobj = Py_None;
12045 return resultobj;
12046 fail:
12047 return NULL;
12048 }
12049
12050
12051 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12052 PyObject *resultobj = NULL;
12053 wxImage *arg1 = (wxImage *) 0 ;
12054 int arg2 ;
12055 int arg3 ;
12056 byte result;
12057 PyObject * obj0 = 0 ;
12058 PyObject * obj1 = 0 ;
12059 PyObject * obj2 = 0 ;
12060 char *kwnames[] = {
12061 (char *) "self",(char *) "x",(char *) "y", NULL
12062 };
12063
12064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12066 if (SWIG_arg_fail(1)) SWIG_fail;
12067 {
12068 arg2 = static_cast<int >(SWIG_As_int(obj1));
12069 if (SWIG_arg_fail(2)) SWIG_fail;
12070 }
12071 {
12072 arg3 = static_cast<int >(SWIG_As_int(obj2));
12073 if (SWIG_arg_fail(3)) SWIG_fail;
12074 }
12075 {
12076 PyThreadState* __tstate = wxPyBeginAllowThreads();
12077 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12078
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 {
12083 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12084 }
12085 return resultobj;
12086 fail:
12087 return NULL;
12088 }
12089
12090
12091 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj = NULL;
12093 wxImage *arg1 = (wxImage *) 0 ;
12094 bool result;
12095 PyObject * obj0 = 0 ;
12096 char *kwnames[] = {
12097 (char *) "self", NULL
12098 };
12099
12100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12102 if (SWIG_arg_fail(1)) SWIG_fail;
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 result = (bool)(arg1)->HasAlpha();
12106
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 {
12111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12112 }
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj = NULL;
12121 wxImage *arg1 = (wxImage *) 0 ;
12122 PyObject * obj0 = 0 ;
12123 char *kwnames[] = {
12124 (char *) "self", NULL
12125 };
12126
12127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12129 if (SWIG_arg_fail(1)) SWIG_fail;
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 (arg1)->InitAlpha();
12133
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 Py_INCREF(Py_None); resultobj = Py_None;
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12145 PyObject *resultobj = NULL;
12146 wxImage *arg1 = (wxImage *) 0 ;
12147 int arg2 ;
12148 int arg3 ;
12149 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12150 bool result;
12151 PyObject * obj0 = 0 ;
12152 PyObject * obj1 = 0 ;
12153 PyObject * obj2 = 0 ;
12154 PyObject * obj3 = 0 ;
12155 char *kwnames[] = {
12156 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12157 };
12158
12159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 arg2 = static_cast<int >(SWIG_As_int(obj1));
12164 if (SWIG_arg_fail(2)) SWIG_fail;
12165 }
12166 {
12167 arg3 = static_cast<int >(SWIG_As_int(obj2));
12168 if (SWIG_arg_fail(3)) SWIG_fail;
12169 }
12170 if (obj3) {
12171 {
12172 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12173 if (SWIG_arg_fail(4)) SWIG_fail;
12174 }
12175 }
12176 {
12177 PyThreadState* __tstate = wxPyBeginAllowThreads();
12178 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12179
12180 wxPyEndAllowThreads(__tstate);
12181 if (PyErr_Occurred()) SWIG_fail;
12182 }
12183 {
12184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12185 }
12186 return resultobj;
12187 fail:
12188 return NULL;
12189 }
12190
12191
12192 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12193 PyObject *resultobj = NULL;
12194 wxImage *arg1 = (wxImage *) 0 ;
12195 byte *arg2 = (byte *) 0 ;
12196 byte *arg3 = (byte *) 0 ;
12197 byte *arg4 = (byte *) 0 ;
12198 byte arg5 = (byte) 0 ;
12199 byte arg6 = (byte) 0 ;
12200 byte arg7 = (byte) 0 ;
12201 bool result;
12202 byte temp2 ;
12203 int res2 = 0 ;
12204 byte temp3 ;
12205 int res3 = 0 ;
12206 byte temp4 ;
12207 int res4 = 0 ;
12208 PyObject * obj0 = 0 ;
12209 PyObject * obj1 = 0 ;
12210 PyObject * obj2 = 0 ;
12211 PyObject * obj3 = 0 ;
12212 char *kwnames[] = {
12213 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12214 };
12215
12216 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12217 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12218 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12221 if (SWIG_arg_fail(1)) SWIG_fail;
12222 if (obj1) {
12223 {
12224 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12225 if (SWIG_arg_fail(5)) SWIG_fail;
12226 }
12227 }
12228 if (obj2) {
12229 {
12230 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12231 if (SWIG_arg_fail(6)) SWIG_fail;
12232 }
12233 }
12234 if (obj3) {
12235 {
12236 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12237 if (SWIG_arg_fail(7)) SWIG_fail;
12238 }
12239 }
12240 {
12241 PyThreadState* __tstate = wxPyBeginAllowThreads();
12242 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12243
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 {
12248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12249 }
12250 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12251 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12252 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12253 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12254 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12255 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj = NULL;
12264 wxImage *arg1 = (wxImage *) 0 ;
12265 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12266 bool result;
12267 PyObject * obj0 = 0 ;
12268 PyObject * obj1 = 0 ;
12269 char *kwnames[] = {
12270 (char *) "self",(char *) "threshold", NULL
12271 };
12272
12273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12275 if (SWIG_arg_fail(1)) SWIG_fail;
12276 if (obj1) {
12277 {
12278 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12279 if (SWIG_arg_fail(2)) SWIG_fail;
12280 }
12281 }
12282 {
12283 PyThreadState* __tstate = wxPyBeginAllowThreads();
12284 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12285
12286 wxPyEndAllowThreads(__tstate);
12287 if (PyErr_Occurred()) SWIG_fail;
12288 }
12289 {
12290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12291 }
12292 return resultobj;
12293 fail:
12294 return NULL;
12295 }
12296
12297
12298 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12299 PyObject *resultobj = NULL;
12300 wxImage *arg1 = (wxImage *) 0 ;
12301 byte arg2 ;
12302 byte arg3 ;
12303 byte arg4 ;
12304 bool result;
12305 PyObject * obj0 = 0 ;
12306 PyObject * obj1 = 0 ;
12307 PyObject * obj2 = 0 ;
12308 PyObject * obj3 = 0 ;
12309 char *kwnames[] = {
12310 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12311 };
12312
12313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12315 if (SWIG_arg_fail(1)) SWIG_fail;
12316 {
12317 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12318 if (SWIG_arg_fail(2)) SWIG_fail;
12319 }
12320 {
12321 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12322 if (SWIG_arg_fail(3)) SWIG_fail;
12323 }
12324 {
12325 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12326 if (SWIG_arg_fail(4)) SWIG_fail;
12327 }
12328 {
12329 PyThreadState* __tstate = wxPyBeginAllowThreads();
12330 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12331
12332 wxPyEndAllowThreads(__tstate);
12333 if (PyErr_Occurred()) SWIG_fail;
12334 }
12335 {
12336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12337 }
12338 return resultobj;
12339 fail:
12340 return NULL;
12341 }
12342
12343
12344 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12345 PyObject *resultobj = NULL;
12346 wxImage *arg1 = (wxImage *) 0 ;
12347 wxImage *arg2 = 0 ;
12348 byte arg3 ;
12349 byte arg4 ;
12350 byte arg5 ;
12351 bool result;
12352 PyObject * obj0 = 0 ;
12353 PyObject * obj1 = 0 ;
12354 PyObject * obj2 = 0 ;
12355 PyObject * obj3 = 0 ;
12356 PyObject * obj4 = 0 ;
12357 char *kwnames[] = {
12358 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12359 };
12360
12361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12363 if (SWIG_arg_fail(1)) SWIG_fail;
12364 {
12365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12366 if (SWIG_arg_fail(2)) SWIG_fail;
12367 if (arg2 == NULL) {
12368 SWIG_null_ref("wxImage");
12369 }
12370 if (SWIG_arg_fail(2)) SWIG_fail;
12371 }
12372 {
12373 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12374 if (SWIG_arg_fail(3)) SWIG_fail;
12375 }
12376 {
12377 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12378 if (SWIG_arg_fail(4)) SWIG_fail;
12379 }
12380 {
12381 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12382 if (SWIG_arg_fail(5)) SWIG_fail;
12383 }
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12387
12388 wxPyEndAllowThreads(__tstate);
12389 if (PyErr_Occurred()) SWIG_fail;
12390 }
12391 {
12392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12393 }
12394 return resultobj;
12395 fail:
12396 return NULL;
12397 }
12398
12399
12400 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12401 PyObject *resultobj = NULL;
12402 wxString *arg1 = 0 ;
12403 bool result;
12404 bool temp1 = false ;
12405 PyObject * obj0 = 0 ;
12406 char *kwnames[] = {
12407 (char *) "filename", NULL
12408 };
12409
12410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12411 {
12412 arg1 = wxString_in_helper(obj0);
12413 if (arg1 == NULL) SWIG_fail;
12414 temp1 = true;
12415 }
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12419
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 {
12424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12425 }
12426 {
12427 if (temp1)
12428 delete arg1;
12429 }
12430 return resultobj;
12431 fail:
12432 {
12433 if (temp1)
12434 delete arg1;
12435 }
12436 return NULL;
12437 }
12438
12439
12440 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12441 PyObject *resultobj = NULL;
12442 wxString *arg1 = 0 ;
12443 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12444 int result;
12445 bool temp1 = false ;
12446 PyObject * obj0 = 0 ;
12447 PyObject * obj1 = 0 ;
12448 char *kwnames[] = {
12449 (char *) "filename",(char *) "type", NULL
12450 };
12451
12452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12453 {
12454 arg1 = wxString_in_helper(obj0);
12455 if (arg1 == NULL) SWIG_fail;
12456 temp1 = true;
12457 }
12458 if (obj1) {
12459 {
12460 arg2 = static_cast<long >(SWIG_As_long(obj1));
12461 if (SWIG_arg_fail(2)) SWIG_fail;
12462 }
12463 }
12464 {
12465 PyThreadState* __tstate = wxPyBeginAllowThreads();
12466 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12467
12468 wxPyEndAllowThreads(__tstate);
12469 if (PyErr_Occurred()) SWIG_fail;
12470 }
12471 {
12472 resultobj = SWIG_From_int(static_cast<int >(result));
12473 }
12474 {
12475 if (temp1)
12476 delete arg1;
12477 }
12478 return resultobj;
12479 fail:
12480 {
12481 if (temp1)
12482 delete arg1;
12483 }
12484 return NULL;
12485 }
12486
12487
12488 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj = NULL;
12490 wxImage *arg1 = (wxImage *) 0 ;
12491 wxString *arg2 = 0 ;
12492 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12493 int arg4 = (int) -1 ;
12494 bool result;
12495 bool temp2 = false ;
12496 PyObject * obj0 = 0 ;
12497 PyObject * obj1 = 0 ;
12498 PyObject * obj2 = 0 ;
12499 PyObject * obj3 = 0 ;
12500 char *kwnames[] = {
12501 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12502 };
12503
12504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12506 if (SWIG_arg_fail(1)) SWIG_fail;
12507 {
12508 arg2 = wxString_in_helper(obj1);
12509 if (arg2 == NULL) SWIG_fail;
12510 temp2 = true;
12511 }
12512 if (obj2) {
12513 {
12514 arg3 = static_cast<long >(SWIG_As_long(obj2));
12515 if (SWIG_arg_fail(3)) SWIG_fail;
12516 }
12517 }
12518 if (obj3) {
12519 {
12520 arg4 = static_cast<int >(SWIG_As_int(obj3));
12521 if (SWIG_arg_fail(4)) SWIG_fail;
12522 }
12523 }
12524 {
12525 PyThreadState* __tstate = wxPyBeginAllowThreads();
12526 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12527
12528 wxPyEndAllowThreads(__tstate);
12529 if (PyErr_Occurred()) SWIG_fail;
12530 }
12531 {
12532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12533 }
12534 {
12535 if (temp2)
12536 delete arg2;
12537 }
12538 return resultobj;
12539 fail:
12540 {
12541 if (temp2)
12542 delete arg2;
12543 }
12544 return NULL;
12545 }
12546
12547
12548 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12549 PyObject *resultobj = NULL;
12550 wxImage *arg1 = (wxImage *) 0 ;
12551 wxString *arg2 = 0 ;
12552 wxString *arg3 = 0 ;
12553 int arg4 = (int) -1 ;
12554 bool result;
12555 bool temp2 = false ;
12556 bool temp3 = false ;
12557 PyObject * obj0 = 0 ;
12558 PyObject * obj1 = 0 ;
12559 PyObject * obj2 = 0 ;
12560 PyObject * obj3 = 0 ;
12561 char *kwnames[] = {
12562 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12563 };
12564
12565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12567 if (SWIG_arg_fail(1)) SWIG_fail;
12568 {
12569 arg2 = wxString_in_helper(obj1);
12570 if (arg2 == NULL) SWIG_fail;
12571 temp2 = true;
12572 }
12573 {
12574 arg3 = wxString_in_helper(obj2);
12575 if (arg3 == NULL) SWIG_fail;
12576 temp3 = true;
12577 }
12578 if (obj3) {
12579 {
12580 arg4 = static_cast<int >(SWIG_As_int(obj3));
12581 if (SWIG_arg_fail(4)) SWIG_fail;
12582 }
12583 }
12584 {
12585 PyThreadState* __tstate = wxPyBeginAllowThreads();
12586 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12587
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 {
12592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12593 }
12594 {
12595 if (temp2)
12596 delete arg2;
12597 }
12598 {
12599 if (temp3)
12600 delete arg3;
12601 }
12602 return resultobj;
12603 fail:
12604 {
12605 if (temp2)
12606 delete arg2;
12607 }
12608 {
12609 if (temp3)
12610 delete arg3;
12611 }
12612 return NULL;
12613 }
12614
12615
12616 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12617 PyObject *resultobj = NULL;
12618 wxImage *arg1 = (wxImage *) 0 ;
12619 wxString *arg2 = 0 ;
12620 int arg3 ;
12621 bool result;
12622 bool temp2 = false ;
12623 PyObject * obj0 = 0 ;
12624 PyObject * obj1 = 0 ;
12625 PyObject * obj2 = 0 ;
12626 char *kwnames[] = {
12627 (char *) "self",(char *) "name",(char *) "type", NULL
12628 };
12629
12630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12632 if (SWIG_arg_fail(1)) SWIG_fail;
12633 {
12634 arg2 = wxString_in_helper(obj1);
12635 if (arg2 == NULL) SWIG_fail;
12636 temp2 = true;
12637 }
12638 {
12639 arg3 = static_cast<int >(SWIG_As_int(obj2));
12640 if (SWIG_arg_fail(3)) SWIG_fail;
12641 }
12642 {
12643 PyThreadState* __tstate = wxPyBeginAllowThreads();
12644 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12645
12646 wxPyEndAllowThreads(__tstate);
12647 if (PyErr_Occurred()) SWIG_fail;
12648 }
12649 {
12650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12651 }
12652 {
12653 if (temp2)
12654 delete arg2;
12655 }
12656 return resultobj;
12657 fail:
12658 {
12659 if (temp2)
12660 delete arg2;
12661 }
12662 return NULL;
12663 }
12664
12665
12666 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12667 PyObject *resultobj = NULL;
12668 wxImage *arg1 = (wxImage *) 0 ;
12669 wxString *arg2 = 0 ;
12670 wxString *arg3 = 0 ;
12671 bool result;
12672 bool temp2 = false ;
12673 bool temp3 = false ;
12674 PyObject * obj0 = 0 ;
12675 PyObject * obj1 = 0 ;
12676 PyObject * obj2 = 0 ;
12677 char *kwnames[] = {
12678 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12679 };
12680
12681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12683 if (SWIG_arg_fail(1)) SWIG_fail;
12684 {
12685 arg2 = wxString_in_helper(obj1);
12686 if (arg2 == NULL) SWIG_fail;
12687 temp2 = true;
12688 }
12689 {
12690 arg3 = wxString_in_helper(obj2);
12691 if (arg3 == NULL) SWIG_fail;
12692 temp3 = true;
12693 }
12694 {
12695 PyThreadState* __tstate = wxPyBeginAllowThreads();
12696 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12697
12698 wxPyEndAllowThreads(__tstate);
12699 if (PyErr_Occurred()) SWIG_fail;
12700 }
12701 {
12702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12703 }
12704 {
12705 if (temp2)
12706 delete arg2;
12707 }
12708 {
12709 if (temp3)
12710 delete arg3;
12711 }
12712 return resultobj;
12713 fail:
12714 {
12715 if (temp2)
12716 delete arg2;
12717 }
12718 {
12719 if (temp3)
12720 delete arg3;
12721 }
12722 return NULL;
12723 }
12724
12725
12726 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12727 PyObject *resultobj = NULL;
12728 wxInputStream *arg1 = 0 ;
12729 bool result;
12730 wxPyInputStream *temp1 ;
12731 bool created1 ;
12732 PyObject * obj0 = 0 ;
12733 char *kwnames[] = {
12734 (char *) "stream", NULL
12735 };
12736
12737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12738 {
12739 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12740 arg1 = temp1->m_wxis;
12741 created1 = false;
12742 } else {
12743 PyErr_Clear(); // clear the failure of the wxPyConvert above
12744 arg1 = wxPyCBInputStream_create(obj0, false);
12745 if (arg1 == NULL) {
12746 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12747 SWIG_fail;
12748 }
12749 created1 = true;
12750 }
12751 }
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 result = (bool)wxImage::CanRead(*arg1);
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 {
12760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12761 }
12762 {
12763 if (created1) delete arg1;
12764 }
12765 return resultobj;
12766 fail:
12767 {
12768 if (created1) delete arg1;
12769 }
12770 return NULL;
12771 }
12772
12773
12774 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12775 PyObject *resultobj = NULL;
12776 wxImage *arg1 = (wxImage *) 0 ;
12777 wxInputStream *arg2 = 0 ;
12778 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12779 int arg4 = (int) -1 ;
12780 bool result;
12781 wxPyInputStream *temp2 ;
12782 bool created2 ;
12783 PyObject * obj0 = 0 ;
12784 PyObject * obj1 = 0 ;
12785 PyObject * obj2 = 0 ;
12786 PyObject * obj3 = 0 ;
12787 char *kwnames[] = {
12788 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12789 };
12790
12791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12793 if (SWIG_arg_fail(1)) SWIG_fail;
12794 {
12795 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12796 arg2 = temp2->m_wxis;
12797 created2 = false;
12798 } else {
12799 PyErr_Clear(); // clear the failure of the wxPyConvert above
12800 arg2 = wxPyCBInputStream_create(obj1, false);
12801 if (arg2 == NULL) {
12802 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12803 SWIG_fail;
12804 }
12805 created2 = true;
12806 }
12807 }
12808 if (obj2) {
12809 {
12810 arg3 = static_cast<long >(SWIG_As_long(obj2));
12811 if (SWIG_arg_fail(3)) SWIG_fail;
12812 }
12813 }
12814 if (obj3) {
12815 {
12816 arg4 = static_cast<int >(SWIG_As_int(obj3));
12817 if (SWIG_arg_fail(4)) SWIG_fail;
12818 }
12819 }
12820 {
12821 PyThreadState* __tstate = wxPyBeginAllowThreads();
12822 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12823
12824 wxPyEndAllowThreads(__tstate);
12825 if (PyErr_Occurred()) SWIG_fail;
12826 }
12827 {
12828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12829 }
12830 {
12831 if (created2) delete arg2;
12832 }
12833 return resultobj;
12834 fail:
12835 {
12836 if (created2) delete arg2;
12837 }
12838 return NULL;
12839 }
12840
12841
12842 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12843 PyObject *resultobj = NULL;
12844 wxImage *arg1 = (wxImage *) 0 ;
12845 wxInputStream *arg2 = 0 ;
12846 wxString *arg3 = 0 ;
12847 int arg4 = (int) -1 ;
12848 bool result;
12849 wxPyInputStream *temp2 ;
12850 bool created2 ;
12851 bool temp3 = false ;
12852 PyObject * obj0 = 0 ;
12853 PyObject * obj1 = 0 ;
12854 PyObject * obj2 = 0 ;
12855 PyObject * obj3 = 0 ;
12856 char *kwnames[] = {
12857 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12858 };
12859
12860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12862 if (SWIG_arg_fail(1)) SWIG_fail;
12863 {
12864 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12865 arg2 = temp2->m_wxis;
12866 created2 = false;
12867 } else {
12868 PyErr_Clear(); // clear the failure of the wxPyConvert above
12869 arg2 = wxPyCBInputStream_create(obj1, false);
12870 if (arg2 == NULL) {
12871 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12872 SWIG_fail;
12873 }
12874 created2 = true;
12875 }
12876 }
12877 {
12878 arg3 = wxString_in_helper(obj2);
12879 if (arg3 == NULL) SWIG_fail;
12880 temp3 = true;
12881 }
12882 if (obj3) {
12883 {
12884 arg4 = static_cast<int >(SWIG_As_int(obj3));
12885 if (SWIG_arg_fail(4)) SWIG_fail;
12886 }
12887 }
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12891
12892 wxPyEndAllowThreads(__tstate);
12893 if (PyErr_Occurred()) SWIG_fail;
12894 }
12895 {
12896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12897 }
12898 {
12899 if (created2) delete arg2;
12900 }
12901 {
12902 if (temp3)
12903 delete arg3;
12904 }
12905 return resultobj;
12906 fail:
12907 {
12908 if (created2) delete arg2;
12909 }
12910 {
12911 if (temp3)
12912 delete arg3;
12913 }
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj = NULL;
12920 wxImage *arg1 = (wxImage *) 0 ;
12921 bool result;
12922 PyObject * obj0 = 0 ;
12923 char *kwnames[] = {
12924 (char *) "self", NULL
12925 };
12926
12927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12929 if (SWIG_arg_fail(1)) SWIG_fail;
12930 {
12931 PyThreadState* __tstate = wxPyBeginAllowThreads();
12932 result = (bool)(arg1)->Ok();
12933
12934 wxPyEndAllowThreads(__tstate);
12935 if (PyErr_Occurred()) SWIG_fail;
12936 }
12937 {
12938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12939 }
12940 return resultobj;
12941 fail:
12942 return NULL;
12943 }
12944
12945
12946 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12947 PyObject *resultobj = NULL;
12948 wxImage *arg1 = (wxImage *) 0 ;
12949 int result;
12950 PyObject * obj0 = 0 ;
12951 char *kwnames[] = {
12952 (char *) "self", NULL
12953 };
12954
12955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12957 if (SWIG_arg_fail(1)) SWIG_fail;
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (int)(arg1)->GetWidth();
12961
12962 wxPyEndAllowThreads(__tstate);
12963 if (PyErr_Occurred()) SWIG_fail;
12964 }
12965 {
12966 resultobj = SWIG_From_int(static_cast<int >(result));
12967 }
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj = NULL;
12976 wxImage *arg1 = (wxImage *) 0 ;
12977 int result;
12978 PyObject * obj0 = 0 ;
12979 char *kwnames[] = {
12980 (char *) "self", NULL
12981 };
12982
12983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12985 if (SWIG_arg_fail(1)) SWIG_fail;
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 result = (int)(arg1)->GetHeight();
12989
12990 wxPyEndAllowThreads(__tstate);
12991 if (PyErr_Occurred()) SWIG_fail;
12992 }
12993 {
12994 resultobj = SWIG_From_int(static_cast<int >(result));
12995 }
12996 return resultobj;
12997 fail:
12998 return NULL;
12999 }
13000
13001
13002 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
13003 PyObject *resultobj = NULL;
13004 wxImage *arg1 = (wxImage *) 0 ;
13005 wxSize result;
13006 PyObject * obj0 = 0 ;
13007 char *kwnames[] = {
13008 (char *) "self", NULL
13009 };
13010
13011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
13012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13013 if (SWIG_arg_fail(1)) SWIG_fail;
13014 {
13015 PyThreadState* __tstate = wxPyBeginAllowThreads();
13016 result = wxImage_GetSize(arg1);
13017
13018 wxPyEndAllowThreads(__tstate);
13019 if (PyErr_Occurred()) SWIG_fail;
13020 }
13021 {
13022 wxSize * resultptr;
13023 resultptr = new wxSize(static_cast<wxSize & >(result));
13024 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
13025 }
13026 return resultobj;
13027 fail:
13028 return NULL;
13029 }
13030
13031
13032 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13033 PyObject *resultobj = NULL;
13034 wxImage *arg1 = (wxImage *) 0 ;
13035 wxRect *arg2 = 0 ;
13036 SwigValueWrapper<wxImage > result;
13037 wxRect temp2 ;
13038 PyObject * obj0 = 0 ;
13039 PyObject * obj1 = 0 ;
13040 char *kwnames[] = {
13041 (char *) "self",(char *) "rect", NULL
13042 };
13043
13044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13046 if (SWIG_arg_fail(1)) SWIG_fail;
13047 {
13048 arg2 = &temp2;
13049 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13050 }
13051 {
13052 PyThreadState* __tstate = wxPyBeginAllowThreads();
13053 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13054
13055 wxPyEndAllowThreads(__tstate);
13056 if (PyErr_Occurred()) SWIG_fail;
13057 }
13058 {
13059 wxImage * resultptr;
13060 resultptr = new wxImage(static_cast<wxImage & >(result));
13061 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13062 }
13063 return resultobj;
13064 fail:
13065 return NULL;
13066 }
13067
13068
13069 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13070 PyObject *resultobj = NULL;
13071 wxImage *arg1 = (wxImage *) 0 ;
13072 wxSize *arg2 = 0 ;
13073 wxPoint *arg3 = 0 ;
13074 int arg4 = (int) -1 ;
13075 int arg5 = (int) -1 ;
13076 int arg6 = (int) -1 ;
13077 SwigValueWrapper<wxImage > result;
13078 wxSize temp2 ;
13079 wxPoint temp3 ;
13080 PyObject * obj0 = 0 ;
13081 PyObject * obj1 = 0 ;
13082 PyObject * obj2 = 0 ;
13083 PyObject * obj3 = 0 ;
13084 PyObject * obj4 = 0 ;
13085 PyObject * obj5 = 0 ;
13086 char *kwnames[] = {
13087 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13088 };
13089
13090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13092 if (SWIG_arg_fail(1)) SWIG_fail;
13093 {
13094 arg2 = &temp2;
13095 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13096 }
13097 {
13098 arg3 = &temp3;
13099 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13100 }
13101 if (obj3) {
13102 {
13103 arg4 = static_cast<int >(SWIG_As_int(obj3));
13104 if (SWIG_arg_fail(4)) SWIG_fail;
13105 }
13106 }
13107 if (obj4) {
13108 {
13109 arg5 = static_cast<int >(SWIG_As_int(obj4));
13110 if (SWIG_arg_fail(5)) SWIG_fail;
13111 }
13112 }
13113 if (obj5) {
13114 {
13115 arg6 = static_cast<int >(SWIG_As_int(obj5));
13116 if (SWIG_arg_fail(6)) SWIG_fail;
13117 }
13118 }
13119 {
13120 PyThreadState* __tstate = wxPyBeginAllowThreads();
13121 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13122
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 {
13127 wxImage * resultptr;
13128 resultptr = new wxImage(static_cast<wxImage & >(result));
13129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13130 }
13131 return resultobj;
13132 fail:
13133 return NULL;
13134 }
13135
13136
13137 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13138 PyObject *resultobj = NULL;
13139 wxImage *arg1 = (wxImage *) 0 ;
13140 SwigValueWrapper<wxImage > result;
13141 PyObject * obj0 = 0 ;
13142 char *kwnames[] = {
13143 (char *) "self", NULL
13144 };
13145
13146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13148 if (SWIG_arg_fail(1)) SWIG_fail;
13149 {
13150 PyThreadState* __tstate = wxPyBeginAllowThreads();
13151 result = (arg1)->Copy();
13152
13153 wxPyEndAllowThreads(__tstate);
13154 if (PyErr_Occurred()) SWIG_fail;
13155 }
13156 {
13157 wxImage * resultptr;
13158 resultptr = new wxImage(static_cast<wxImage & >(result));
13159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj = NULL;
13169 wxImage *arg1 = (wxImage *) 0 ;
13170 wxImage *arg2 = 0 ;
13171 int arg3 ;
13172 int arg4 ;
13173 PyObject * obj0 = 0 ;
13174 PyObject * obj1 = 0 ;
13175 PyObject * obj2 = 0 ;
13176 PyObject * obj3 = 0 ;
13177 char *kwnames[] = {
13178 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13179 };
13180
13181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13183 if (SWIG_arg_fail(1)) SWIG_fail;
13184 {
13185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13186 if (SWIG_arg_fail(2)) SWIG_fail;
13187 if (arg2 == NULL) {
13188 SWIG_null_ref("wxImage");
13189 }
13190 if (SWIG_arg_fail(2)) SWIG_fail;
13191 }
13192 {
13193 arg3 = static_cast<int >(SWIG_As_int(obj2));
13194 if (SWIG_arg_fail(3)) SWIG_fail;
13195 }
13196 {
13197 arg4 = static_cast<int >(SWIG_As_int(obj3));
13198 if (SWIG_arg_fail(4)) SWIG_fail;
13199 }
13200 {
13201 PyThreadState* __tstate = wxPyBeginAllowThreads();
13202 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13203
13204 wxPyEndAllowThreads(__tstate);
13205 if (PyErr_Occurred()) SWIG_fail;
13206 }
13207 Py_INCREF(Py_None); resultobj = Py_None;
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj = NULL;
13216 wxImage *arg1 = (wxImage *) 0 ;
13217 PyObject *result;
13218 PyObject * obj0 = 0 ;
13219 char *kwnames[] = {
13220 (char *) "self", NULL
13221 };
13222
13223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13225 if (SWIG_arg_fail(1)) SWIG_fail;
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 result = (PyObject *)wxImage_GetData(arg1);
13229
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 resultobj = result;
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13241 PyObject *resultobj = NULL;
13242 wxImage *arg1 = (wxImage *) 0 ;
13243 buffer arg2 ;
13244 int arg3 ;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 char *kwnames[] = {
13248 (char *) "self",(char *) "data", NULL
13249 };
13250
13251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13253 if (SWIG_arg_fail(1)) SWIG_fail;
13254 {
13255 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13256 }
13257 {
13258 PyThreadState* __tstate = wxPyBeginAllowThreads();
13259 wxImage_SetData(arg1,arg2,arg3);
13260
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 Py_INCREF(Py_None); resultobj = Py_None;
13265 return resultobj;
13266 fail:
13267 return NULL;
13268 }
13269
13270
13271 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13272 PyObject *resultobj = NULL;
13273 wxImage *arg1 = (wxImage *) 0 ;
13274 PyObject *result;
13275 PyObject * obj0 = 0 ;
13276 char *kwnames[] = {
13277 (char *) "self", NULL
13278 };
13279
13280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13282 if (SWIG_arg_fail(1)) SWIG_fail;
13283 {
13284 PyThreadState* __tstate = wxPyBeginAllowThreads();
13285 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13286
13287 wxPyEndAllowThreads(__tstate);
13288 if (PyErr_Occurred()) SWIG_fail;
13289 }
13290 resultobj = result;
13291 return resultobj;
13292 fail:
13293 return NULL;
13294 }
13295
13296
13297 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13298 PyObject *resultobj = NULL;
13299 wxImage *arg1 = (wxImage *) 0 ;
13300 buffer arg2 ;
13301 int arg3 ;
13302 PyObject * obj0 = 0 ;
13303 PyObject * obj1 = 0 ;
13304 char *kwnames[] = {
13305 (char *) "self",(char *) "data", NULL
13306 };
13307
13308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13310 if (SWIG_arg_fail(1)) SWIG_fail;
13311 {
13312 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13313 }
13314 {
13315 PyThreadState* __tstate = wxPyBeginAllowThreads();
13316 wxImage_SetDataBuffer(arg1,arg2,arg3);
13317
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 Py_INCREF(Py_None); resultobj = Py_None;
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj = NULL;
13330 wxImage *arg1 = (wxImage *) 0 ;
13331 PyObject *result;
13332 PyObject * obj0 = 0 ;
13333 char *kwnames[] = {
13334 (char *) "self", NULL
13335 };
13336
13337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13339 if (SWIG_arg_fail(1)) SWIG_fail;
13340 {
13341 PyThreadState* __tstate = wxPyBeginAllowThreads();
13342 result = (PyObject *)wxImage_GetAlphaData(arg1);
13343
13344 wxPyEndAllowThreads(__tstate);
13345 if (PyErr_Occurred()) SWIG_fail;
13346 }
13347 resultobj = result;
13348 return resultobj;
13349 fail:
13350 return NULL;
13351 }
13352
13353
13354 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13355 PyObject *resultobj = NULL;
13356 wxImage *arg1 = (wxImage *) 0 ;
13357 buffer arg2 ;
13358 int arg3 ;
13359 PyObject * obj0 = 0 ;
13360 PyObject * obj1 = 0 ;
13361 char *kwnames[] = {
13362 (char *) "self",(char *) "alpha", NULL
13363 };
13364
13365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13367 if (SWIG_arg_fail(1)) SWIG_fail;
13368 {
13369 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13370 }
13371 {
13372 PyThreadState* __tstate = wxPyBeginAllowThreads();
13373 wxImage_SetAlphaData(arg1,arg2,arg3);
13374
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 Py_INCREF(Py_None); resultobj = Py_None;
13379 return resultobj;
13380 fail:
13381 return NULL;
13382 }
13383
13384
13385 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13386 PyObject *resultobj = NULL;
13387 wxImage *arg1 = (wxImage *) 0 ;
13388 PyObject *result;
13389 PyObject * obj0 = 0 ;
13390 char *kwnames[] = {
13391 (char *) "self", NULL
13392 };
13393
13394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13396 if (SWIG_arg_fail(1)) SWIG_fail;
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13400
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 resultobj = result;
13405 return resultobj;
13406 fail:
13407 return NULL;
13408 }
13409
13410
13411 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13412 PyObject *resultobj = NULL;
13413 wxImage *arg1 = (wxImage *) 0 ;
13414 buffer arg2 ;
13415 int arg3 ;
13416 PyObject * obj0 = 0 ;
13417 PyObject * obj1 = 0 ;
13418 char *kwnames[] = {
13419 (char *) "self",(char *) "alpha", NULL
13420 };
13421
13422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13424 if (SWIG_arg_fail(1)) SWIG_fail;
13425 {
13426 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13427 }
13428 {
13429 PyThreadState* __tstate = wxPyBeginAllowThreads();
13430 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13431
13432 wxPyEndAllowThreads(__tstate);
13433 if (PyErr_Occurred()) SWIG_fail;
13434 }
13435 Py_INCREF(Py_None); resultobj = Py_None;
13436 return resultobj;
13437 fail:
13438 return NULL;
13439 }
13440
13441
13442 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13443 PyObject *resultobj = NULL;
13444 wxImage *arg1 = (wxImage *) 0 ;
13445 byte arg2 ;
13446 byte arg3 ;
13447 byte arg4 ;
13448 PyObject * obj0 = 0 ;
13449 PyObject * obj1 = 0 ;
13450 PyObject * obj2 = 0 ;
13451 PyObject * obj3 = 0 ;
13452 char *kwnames[] = {
13453 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13454 };
13455
13456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13458 if (SWIG_arg_fail(1)) SWIG_fail;
13459 {
13460 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13461 if (SWIG_arg_fail(2)) SWIG_fail;
13462 }
13463 {
13464 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13465 if (SWIG_arg_fail(3)) SWIG_fail;
13466 }
13467 {
13468 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13469 if (SWIG_arg_fail(4)) SWIG_fail;
13470 }
13471 {
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 (arg1)->SetMaskColour(arg2,arg3,arg4);
13474
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 Py_INCREF(Py_None); resultobj = Py_None;
13479 return resultobj;
13480 fail:
13481 return NULL;
13482 }
13483
13484
13485 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj = NULL;
13487 wxImage *arg1 = (wxImage *) 0 ;
13488 byte *arg2 = (byte *) 0 ;
13489 byte *arg3 = (byte *) 0 ;
13490 byte *arg4 = (byte *) 0 ;
13491 byte temp2 ;
13492 int res2 = 0 ;
13493 byte temp3 ;
13494 int res3 = 0 ;
13495 byte temp4 ;
13496 int res4 = 0 ;
13497 PyObject * obj0 = 0 ;
13498 char *kwnames[] = {
13499 (char *) "self", NULL
13500 };
13501
13502 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13503 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13504 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13507 if (SWIG_arg_fail(1)) SWIG_fail;
13508 {
13509 PyThreadState* __tstate = wxPyBeginAllowThreads();
13510 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13511
13512 wxPyEndAllowThreads(__tstate);
13513 if (PyErr_Occurred()) SWIG_fail;
13514 }
13515 Py_INCREF(Py_None); resultobj = Py_None;
13516 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13517 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13518 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13519 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13520 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13521 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13522 return resultobj;
13523 fail:
13524 return NULL;
13525 }
13526
13527
13528 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13529 PyObject *resultobj = NULL;
13530 wxImage *arg1 = (wxImage *) 0 ;
13531 byte result;
13532 PyObject * obj0 = 0 ;
13533 char *kwnames[] = {
13534 (char *) "self", NULL
13535 };
13536
13537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",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 result = (byte)(arg1)->GetMaskRed();
13543
13544 wxPyEndAllowThreads(__tstate);
13545 if (PyErr_Occurred()) SWIG_fail;
13546 }
13547 {
13548 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13549 }
13550 return resultobj;
13551 fail:
13552 return NULL;
13553 }
13554
13555
13556 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13557 PyObject *resultobj = NULL;
13558 wxImage *arg1 = (wxImage *) 0 ;
13559 byte result;
13560 PyObject * obj0 = 0 ;
13561 char *kwnames[] = {
13562 (char *) "self", NULL
13563 };
13564
13565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13567 if (SWIG_arg_fail(1)) SWIG_fail;
13568 {
13569 PyThreadState* __tstate = wxPyBeginAllowThreads();
13570 result = (byte)(arg1)->GetMaskGreen();
13571
13572 wxPyEndAllowThreads(__tstate);
13573 if (PyErr_Occurred()) SWIG_fail;
13574 }
13575 {
13576 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13577 }
13578 return resultobj;
13579 fail:
13580 return NULL;
13581 }
13582
13583
13584 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13585 PyObject *resultobj = NULL;
13586 wxImage *arg1 = (wxImage *) 0 ;
13587 byte result;
13588 PyObject * obj0 = 0 ;
13589 char *kwnames[] = {
13590 (char *) "self", NULL
13591 };
13592
13593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13595 if (SWIG_arg_fail(1)) SWIG_fail;
13596 {
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 result = (byte)(arg1)->GetMaskBlue();
13599
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 {
13604 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13605 }
13606 return resultobj;
13607 fail:
13608 return NULL;
13609 }
13610
13611
13612 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13613 PyObject *resultobj = NULL;
13614 wxImage *arg1 = (wxImage *) 0 ;
13615 bool arg2 = (bool) true ;
13616 PyObject * obj0 = 0 ;
13617 PyObject * obj1 = 0 ;
13618 char *kwnames[] = {
13619 (char *) "self",(char *) "mask", NULL
13620 };
13621
13622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13624 if (SWIG_arg_fail(1)) SWIG_fail;
13625 if (obj1) {
13626 {
13627 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13628 if (SWIG_arg_fail(2)) SWIG_fail;
13629 }
13630 }
13631 {
13632 PyThreadState* __tstate = wxPyBeginAllowThreads();
13633 (arg1)->SetMask(arg2);
13634
13635 wxPyEndAllowThreads(__tstate);
13636 if (PyErr_Occurred()) SWIG_fail;
13637 }
13638 Py_INCREF(Py_None); resultobj = Py_None;
13639 return resultobj;
13640 fail:
13641 return NULL;
13642 }
13643
13644
13645 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13646 PyObject *resultobj = NULL;
13647 wxImage *arg1 = (wxImage *) 0 ;
13648 bool result;
13649 PyObject * obj0 = 0 ;
13650 char *kwnames[] = {
13651 (char *) "self", NULL
13652 };
13653
13654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) 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 {
13658 PyThreadState* __tstate = wxPyBeginAllowThreads();
13659 result = (bool)(arg1)->HasMask();
13660
13661 wxPyEndAllowThreads(__tstate);
13662 if (PyErr_Occurred()) SWIG_fail;
13663 }
13664 {
13665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13666 }
13667 return resultobj;
13668 fail:
13669 return NULL;
13670 }
13671
13672
13673 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13674 PyObject *resultobj = NULL;
13675 wxImage *arg1 = (wxImage *) 0 ;
13676 double arg2 ;
13677 wxPoint *arg3 = 0 ;
13678 bool arg4 = (bool) true ;
13679 wxPoint *arg5 = (wxPoint *) NULL ;
13680 SwigValueWrapper<wxImage > result;
13681 wxPoint temp3 ;
13682 PyObject * obj0 = 0 ;
13683 PyObject * obj1 = 0 ;
13684 PyObject * obj2 = 0 ;
13685 PyObject * obj3 = 0 ;
13686 PyObject * obj4 = 0 ;
13687 char *kwnames[] = {
13688 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13689 };
13690
13691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13693 if (SWIG_arg_fail(1)) SWIG_fail;
13694 {
13695 arg2 = static_cast<double >(SWIG_As_double(obj1));
13696 if (SWIG_arg_fail(2)) SWIG_fail;
13697 }
13698 {
13699 arg3 = &temp3;
13700 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13701 }
13702 if (obj3) {
13703 {
13704 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13705 if (SWIG_arg_fail(4)) SWIG_fail;
13706 }
13707 }
13708 if (obj4) {
13709 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13710 if (SWIG_arg_fail(5)) SWIG_fail;
13711 }
13712 {
13713 PyThreadState* __tstate = wxPyBeginAllowThreads();
13714 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13715
13716 wxPyEndAllowThreads(__tstate);
13717 if (PyErr_Occurred()) SWIG_fail;
13718 }
13719 {
13720 wxImage * resultptr;
13721 resultptr = new wxImage(static_cast<wxImage & >(result));
13722 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13723 }
13724 return resultobj;
13725 fail:
13726 return NULL;
13727 }
13728
13729
13730 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13731 PyObject *resultobj = NULL;
13732 wxImage *arg1 = (wxImage *) 0 ;
13733 bool arg2 = (bool) true ;
13734 SwigValueWrapper<wxImage > result;
13735 PyObject * obj0 = 0 ;
13736 PyObject * obj1 = 0 ;
13737 char *kwnames[] = {
13738 (char *) "self",(char *) "clockwise", NULL
13739 };
13740
13741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13743 if (SWIG_arg_fail(1)) SWIG_fail;
13744 if (obj1) {
13745 {
13746 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13747 if (SWIG_arg_fail(2)) SWIG_fail;
13748 }
13749 }
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = (arg1)->Rotate90(arg2);
13753
13754 wxPyEndAllowThreads(__tstate);
13755 if (PyErr_Occurred()) SWIG_fail;
13756 }
13757 {
13758 wxImage * resultptr;
13759 resultptr = new wxImage(static_cast<wxImage & >(result));
13760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13761 }
13762 return resultobj;
13763 fail:
13764 return NULL;
13765 }
13766
13767
13768 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13769 PyObject *resultobj = NULL;
13770 wxImage *arg1 = (wxImage *) 0 ;
13771 bool arg2 = (bool) true ;
13772 SwigValueWrapper<wxImage > result;
13773 PyObject * obj0 = 0 ;
13774 PyObject * obj1 = 0 ;
13775 char *kwnames[] = {
13776 (char *) "self",(char *) "horizontally", NULL
13777 };
13778
13779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13781 if (SWIG_arg_fail(1)) SWIG_fail;
13782 if (obj1) {
13783 {
13784 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13785 if (SWIG_arg_fail(2)) SWIG_fail;
13786 }
13787 }
13788 {
13789 PyThreadState* __tstate = wxPyBeginAllowThreads();
13790 result = (arg1)->Mirror(arg2);
13791
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 {
13796 wxImage * resultptr;
13797 resultptr = new wxImage(static_cast<wxImage & >(result));
13798 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13799 }
13800 return resultobj;
13801 fail:
13802 return NULL;
13803 }
13804
13805
13806 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13807 PyObject *resultobj = NULL;
13808 wxImage *arg1 = (wxImage *) 0 ;
13809 byte arg2 ;
13810 byte arg3 ;
13811 byte arg4 ;
13812 byte arg5 ;
13813 byte arg6 ;
13814 byte arg7 ;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 PyObject * obj3 = 0 ;
13819 PyObject * obj4 = 0 ;
13820 PyObject * obj5 = 0 ;
13821 PyObject * obj6 = 0 ;
13822 char *kwnames[] = {
13823 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13824 };
13825
13826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13828 if (SWIG_arg_fail(1)) SWIG_fail;
13829 {
13830 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13831 if (SWIG_arg_fail(2)) SWIG_fail;
13832 }
13833 {
13834 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13835 if (SWIG_arg_fail(3)) SWIG_fail;
13836 }
13837 {
13838 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13839 if (SWIG_arg_fail(4)) SWIG_fail;
13840 }
13841 {
13842 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13843 if (SWIG_arg_fail(5)) SWIG_fail;
13844 }
13845 {
13846 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13847 if (SWIG_arg_fail(6)) SWIG_fail;
13848 }
13849 {
13850 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13851 if (SWIG_arg_fail(7)) SWIG_fail;
13852 }
13853 {
13854 PyThreadState* __tstate = wxPyBeginAllowThreads();
13855 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13856
13857 wxPyEndAllowThreads(__tstate);
13858 if (PyErr_Occurred()) SWIG_fail;
13859 }
13860 Py_INCREF(Py_None); resultobj = Py_None;
13861 return resultobj;
13862 fail:
13863 return NULL;
13864 }
13865
13866
13867 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13868 PyObject *resultobj = NULL;
13869 wxImage *arg1 = (wxImage *) 0 ;
13870 double arg2 = (double) 0.299 ;
13871 double arg3 = (double) 0.587 ;
13872 double arg4 = (double) 0.114 ;
13873 SwigValueWrapper<wxImage > result;
13874 PyObject * obj0 = 0 ;
13875 PyObject * obj1 = 0 ;
13876 PyObject * obj2 = 0 ;
13877 PyObject * obj3 = 0 ;
13878 char *kwnames[] = {
13879 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13880 };
13881
13882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13884 if (SWIG_arg_fail(1)) SWIG_fail;
13885 if (obj1) {
13886 {
13887 arg2 = static_cast<double >(SWIG_As_double(obj1));
13888 if (SWIG_arg_fail(2)) SWIG_fail;
13889 }
13890 }
13891 if (obj2) {
13892 {
13893 arg3 = static_cast<double >(SWIG_As_double(obj2));
13894 if (SWIG_arg_fail(3)) SWIG_fail;
13895 }
13896 }
13897 if (obj3) {
13898 {
13899 arg4 = static_cast<double >(SWIG_As_double(obj3));
13900 if (SWIG_arg_fail(4)) SWIG_fail;
13901 }
13902 }
13903 {
13904 PyThreadState* __tstate = wxPyBeginAllowThreads();
13905 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13906
13907 wxPyEndAllowThreads(__tstate);
13908 if (PyErr_Occurred()) SWIG_fail;
13909 }
13910 {
13911 wxImage * resultptr;
13912 resultptr = new wxImage(static_cast<wxImage & >(result));
13913 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13914 }
13915 return resultobj;
13916 fail:
13917 return NULL;
13918 }
13919
13920
13921 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj = NULL;
13923 wxImage *arg1 = (wxImage *) 0 ;
13924 byte arg2 ;
13925 byte arg3 ;
13926 byte arg4 ;
13927 SwigValueWrapper<wxImage > result;
13928 PyObject * obj0 = 0 ;
13929 PyObject * obj1 = 0 ;
13930 PyObject * obj2 = 0 ;
13931 PyObject * obj3 = 0 ;
13932 char *kwnames[] = {
13933 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13934 };
13935
13936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13938 if (SWIG_arg_fail(1)) SWIG_fail;
13939 {
13940 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13941 if (SWIG_arg_fail(2)) SWIG_fail;
13942 }
13943 {
13944 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13945 if (SWIG_arg_fail(3)) SWIG_fail;
13946 }
13947 {
13948 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13949 if (SWIG_arg_fail(4)) SWIG_fail;
13950 }
13951 {
13952 PyThreadState* __tstate = wxPyBeginAllowThreads();
13953 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13954
13955 wxPyEndAllowThreads(__tstate);
13956 if (PyErr_Occurred()) SWIG_fail;
13957 }
13958 {
13959 wxImage * resultptr;
13960 resultptr = new wxImage(static_cast<wxImage & >(result));
13961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13962 }
13963 return resultobj;
13964 fail:
13965 return NULL;
13966 }
13967
13968
13969 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13970 PyObject *resultobj = NULL;
13971 wxImage *arg1 = (wxImage *) 0 ;
13972 wxString *arg2 = 0 ;
13973 wxString *arg3 = 0 ;
13974 bool temp2 = false ;
13975 bool temp3 = false ;
13976 PyObject * obj0 = 0 ;
13977 PyObject * obj1 = 0 ;
13978 PyObject * obj2 = 0 ;
13979 char *kwnames[] = {
13980 (char *) "self",(char *) "name",(char *) "value", NULL
13981 };
13982
13983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13985 if (SWIG_arg_fail(1)) SWIG_fail;
13986 {
13987 arg2 = wxString_in_helper(obj1);
13988 if (arg2 == NULL) SWIG_fail;
13989 temp2 = true;
13990 }
13991 {
13992 arg3 = wxString_in_helper(obj2);
13993 if (arg3 == NULL) SWIG_fail;
13994 temp3 = true;
13995 }
13996 {
13997 PyThreadState* __tstate = wxPyBeginAllowThreads();
13998 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13999
14000 wxPyEndAllowThreads(__tstate);
14001 if (PyErr_Occurred()) SWIG_fail;
14002 }
14003 Py_INCREF(Py_None); resultobj = Py_None;
14004 {
14005 if (temp2)
14006 delete arg2;
14007 }
14008 {
14009 if (temp3)
14010 delete arg3;
14011 }
14012 return resultobj;
14013 fail:
14014 {
14015 if (temp2)
14016 delete arg2;
14017 }
14018 {
14019 if (temp3)
14020 delete arg3;
14021 }
14022 return NULL;
14023 }
14024
14025
14026 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj = NULL;
14028 wxImage *arg1 = (wxImage *) 0 ;
14029 wxString *arg2 = 0 ;
14030 int arg3 ;
14031 bool temp2 = false ;
14032 PyObject * obj0 = 0 ;
14033 PyObject * obj1 = 0 ;
14034 PyObject * obj2 = 0 ;
14035 char *kwnames[] = {
14036 (char *) "self",(char *) "name",(char *) "value", NULL
14037 };
14038
14039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14041 if (SWIG_arg_fail(1)) SWIG_fail;
14042 {
14043 arg2 = wxString_in_helper(obj1);
14044 if (arg2 == NULL) SWIG_fail;
14045 temp2 = true;
14046 }
14047 {
14048 arg3 = static_cast<int >(SWIG_As_int(obj2));
14049 if (SWIG_arg_fail(3)) SWIG_fail;
14050 }
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 (arg1)->SetOption((wxString const &)*arg2,arg3);
14054
14055 wxPyEndAllowThreads(__tstate);
14056 if (PyErr_Occurred()) SWIG_fail;
14057 }
14058 Py_INCREF(Py_None); resultobj = Py_None;
14059 {
14060 if (temp2)
14061 delete arg2;
14062 }
14063 return resultobj;
14064 fail:
14065 {
14066 if (temp2)
14067 delete arg2;
14068 }
14069 return NULL;
14070 }
14071
14072
14073 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14074 PyObject *resultobj = NULL;
14075 wxImage *arg1 = (wxImage *) 0 ;
14076 wxString *arg2 = 0 ;
14077 wxString result;
14078 bool temp2 = false ;
14079 PyObject * obj0 = 0 ;
14080 PyObject * obj1 = 0 ;
14081 char *kwnames[] = {
14082 (char *) "self",(char *) "name", NULL
14083 };
14084
14085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14087 if (SWIG_arg_fail(1)) SWIG_fail;
14088 {
14089 arg2 = wxString_in_helper(obj1);
14090 if (arg2 == NULL) SWIG_fail;
14091 temp2 = true;
14092 }
14093 {
14094 PyThreadState* __tstate = wxPyBeginAllowThreads();
14095 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14096
14097 wxPyEndAllowThreads(__tstate);
14098 if (PyErr_Occurred()) SWIG_fail;
14099 }
14100 {
14101 #if wxUSE_UNICODE
14102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14103 #else
14104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14105 #endif
14106 }
14107 {
14108 if (temp2)
14109 delete arg2;
14110 }
14111 return resultobj;
14112 fail:
14113 {
14114 if (temp2)
14115 delete arg2;
14116 }
14117 return NULL;
14118 }
14119
14120
14121 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14122 PyObject *resultobj = NULL;
14123 wxImage *arg1 = (wxImage *) 0 ;
14124 wxString *arg2 = 0 ;
14125 int result;
14126 bool temp2 = false ;
14127 PyObject * obj0 = 0 ;
14128 PyObject * obj1 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "self",(char *) "name", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 arg2 = wxString_in_helper(obj1);
14138 if (arg2 == NULL) SWIG_fail;
14139 temp2 = true;
14140 }
14141 {
14142 PyThreadState* __tstate = wxPyBeginAllowThreads();
14143 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14144
14145 wxPyEndAllowThreads(__tstate);
14146 if (PyErr_Occurred()) SWIG_fail;
14147 }
14148 {
14149 resultobj = SWIG_From_int(static_cast<int >(result));
14150 }
14151 {
14152 if (temp2)
14153 delete arg2;
14154 }
14155 return resultobj;
14156 fail:
14157 {
14158 if (temp2)
14159 delete arg2;
14160 }
14161 return NULL;
14162 }
14163
14164
14165 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14166 PyObject *resultobj = NULL;
14167 wxImage *arg1 = (wxImage *) 0 ;
14168 wxString *arg2 = 0 ;
14169 bool result;
14170 bool temp2 = false ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 char *kwnames[] = {
14174 (char *) "self",(char *) "name", NULL
14175 };
14176
14177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14179 if (SWIG_arg_fail(1)) SWIG_fail;
14180 {
14181 arg2 = wxString_in_helper(obj1);
14182 if (arg2 == NULL) SWIG_fail;
14183 temp2 = true;
14184 }
14185 {
14186 PyThreadState* __tstate = wxPyBeginAllowThreads();
14187 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14188
14189 wxPyEndAllowThreads(__tstate);
14190 if (PyErr_Occurred()) SWIG_fail;
14191 }
14192 {
14193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14194 }
14195 {
14196 if (temp2)
14197 delete arg2;
14198 }
14199 return resultobj;
14200 fail:
14201 {
14202 if (temp2)
14203 delete arg2;
14204 }
14205 return NULL;
14206 }
14207
14208
14209 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14210 PyObject *resultobj = NULL;
14211 wxImage *arg1 = (wxImage *) 0 ;
14212 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14213 unsigned long result;
14214 PyObject * obj0 = 0 ;
14215 PyObject * obj1 = 0 ;
14216 char *kwnames[] = {
14217 (char *) "self",(char *) "stopafter", NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14222 if (SWIG_arg_fail(1)) SWIG_fail;
14223 if (obj1) {
14224 {
14225 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14226 if (SWIG_arg_fail(2)) SWIG_fail;
14227 }
14228 }
14229 {
14230 PyThreadState* __tstate = wxPyBeginAllowThreads();
14231 result = (unsigned long)(arg1)->CountColours(arg2);
14232
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 {
14237 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14238 }
14239 return resultobj;
14240 fail:
14241 return NULL;
14242 }
14243
14244
14245 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14246 PyObject *resultobj = NULL;
14247 wxImage *arg1 = (wxImage *) 0 ;
14248 wxImageHistogram *arg2 = 0 ;
14249 unsigned long result;
14250 PyObject * obj0 = 0 ;
14251 PyObject * obj1 = 0 ;
14252 char *kwnames[] = {
14253 (char *) "self",(char *) "h", NULL
14254 };
14255
14256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14258 if (SWIG_arg_fail(1)) SWIG_fail;
14259 {
14260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14261 if (SWIG_arg_fail(2)) SWIG_fail;
14262 if (arg2 == NULL) {
14263 SWIG_null_ref("wxImageHistogram");
14264 }
14265 if (SWIG_arg_fail(2)) SWIG_fail;
14266 }
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14270
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 {
14275 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14276 }
14277 return resultobj;
14278 fail:
14279 return NULL;
14280 }
14281
14282
14283 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14284 PyObject *resultobj = NULL;
14285 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14286 PyObject * obj0 = 0 ;
14287 char *kwnames[] = {
14288 (char *) "handler", NULL
14289 };
14290
14291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14293 if (SWIG_arg_fail(1)) SWIG_fail;
14294 {
14295 PyThreadState* __tstate = wxPyBeginAllowThreads();
14296 wxImage::AddHandler(arg1);
14297
14298 wxPyEndAllowThreads(__tstate);
14299 if (PyErr_Occurred()) SWIG_fail;
14300 }
14301 Py_INCREF(Py_None); resultobj = Py_None;
14302 return resultobj;
14303 fail:
14304 return NULL;
14305 }
14306
14307
14308 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14309 PyObject *resultobj = NULL;
14310 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14311 PyObject * obj0 = 0 ;
14312 char *kwnames[] = {
14313 (char *) "handler", NULL
14314 };
14315
14316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14318 if (SWIG_arg_fail(1)) SWIG_fail;
14319 {
14320 PyThreadState* __tstate = wxPyBeginAllowThreads();
14321 wxImage::InsertHandler(arg1);
14322
14323 wxPyEndAllowThreads(__tstate);
14324 if (PyErr_Occurred()) SWIG_fail;
14325 }
14326 Py_INCREF(Py_None); resultobj = Py_None;
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14334 PyObject *resultobj = NULL;
14335 wxString *arg1 = 0 ;
14336 bool result;
14337 bool temp1 = false ;
14338 PyObject * obj0 = 0 ;
14339 char *kwnames[] = {
14340 (char *) "name", NULL
14341 };
14342
14343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14344 {
14345 arg1 = wxString_in_helper(obj0);
14346 if (arg1 == NULL) SWIG_fail;
14347 temp1 = true;
14348 }
14349 {
14350 PyThreadState* __tstate = wxPyBeginAllowThreads();
14351 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14352
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 {
14357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14358 }
14359 {
14360 if (temp1)
14361 delete arg1;
14362 }
14363 return resultobj;
14364 fail:
14365 {
14366 if (temp1)
14367 delete arg1;
14368 }
14369 return NULL;
14370 }
14371
14372
14373 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14374 PyObject *resultobj = NULL;
14375 wxString result;
14376 char *kwnames[] = {
14377 NULL
14378 };
14379
14380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14381 {
14382 PyThreadState* __tstate = wxPyBeginAllowThreads();
14383 result = wxImage::GetImageExtWildcard();
14384
14385 wxPyEndAllowThreads(__tstate);
14386 if (PyErr_Occurred()) SWIG_fail;
14387 }
14388 {
14389 #if wxUSE_UNICODE
14390 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14391 #else
14392 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14393 #endif
14394 }
14395 return resultobj;
14396 fail:
14397 return NULL;
14398 }
14399
14400
14401 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14402 PyObject *resultobj = NULL;
14403 wxImage *arg1 = (wxImage *) 0 ;
14404 int arg2 = (int) -1 ;
14405 wxBitmap result;
14406 PyObject * obj0 = 0 ;
14407 PyObject * obj1 = 0 ;
14408 char *kwnames[] = {
14409 (char *) "self",(char *) "depth", NULL
14410 };
14411
14412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14414 if (SWIG_arg_fail(1)) SWIG_fail;
14415 if (obj1) {
14416 {
14417 arg2 = static_cast<int >(SWIG_As_int(obj1));
14418 if (SWIG_arg_fail(2)) SWIG_fail;
14419 }
14420 }
14421 {
14422 if (!wxPyCheckForApp()) SWIG_fail;
14423 PyThreadState* __tstate = wxPyBeginAllowThreads();
14424 result = wxImage_ConvertToBitmap(arg1,arg2);
14425
14426 wxPyEndAllowThreads(__tstate);
14427 if (PyErr_Occurred()) SWIG_fail;
14428 }
14429 {
14430 wxBitmap * resultptr;
14431 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14432 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14433 }
14434 return resultobj;
14435 fail:
14436 return NULL;
14437 }
14438
14439
14440 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14441 PyObject *resultobj = NULL;
14442 wxImage *arg1 = (wxImage *) 0 ;
14443 byte arg2 ;
14444 byte arg3 ;
14445 byte arg4 ;
14446 wxBitmap result;
14447 PyObject * obj0 = 0 ;
14448 PyObject * obj1 = 0 ;
14449 PyObject * obj2 = 0 ;
14450 PyObject * obj3 = 0 ;
14451 char *kwnames[] = {
14452 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14453 };
14454
14455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14457 if (SWIG_arg_fail(1)) SWIG_fail;
14458 {
14459 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14460 if (SWIG_arg_fail(2)) SWIG_fail;
14461 }
14462 {
14463 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14464 if (SWIG_arg_fail(3)) SWIG_fail;
14465 }
14466 {
14467 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14468 if (SWIG_arg_fail(4)) SWIG_fail;
14469 }
14470 {
14471 if (!wxPyCheckForApp()) SWIG_fail;
14472 PyThreadState* __tstate = wxPyBeginAllowThreads();
14473 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14474
14475 wxPyEndAllowThreads(__tstate);
14476 if (PyErr_Occurred()) SWIG_fail;
14477 }
14478 {
14479 wxBitmap * resultptr;
14480 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14482 }
14483 return resultobj;
14484 fail:
14485 return NULL;
14486 }
14487
14488
14489 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14490 PyObject *resultobj = NULL;
14491 wxImage *arg1 = (wxImage *) 0 ;
14492 double arg2 ;
14493 PyObject * obj0 = 0 ;
14494 PyObject * obj1 = 0 ;
14495 char *kwnames[] = {
14496 (char *) "self",(char *) "angle", NULL
14497 };
14498
14499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14501 if (SWIG_arg_fail(1)) SWIG_fail;
14502 {
14503 arg2 = static_cast<double >(SWIG_As_double(obj1));
14504 if (SWIG_arg_fail(2)) SWIG_fail;
14505 }
14506 {
14507 PyThreadState* __tstate = wxPyBeginAllowThreads();
14508 (arg1)->RotateHue(arg2);
14509
14510 wxPyEndAllowThreads(__tstate);
14511 if (PyErr_Occurred()) SWIG_fail;
14512 }
14513 Py_INCREF(Py_None); resultobj = Py_None;
14514 return resultobj;
14515 fail:
14516 return NULL;
14517 }
14518
14519
14520 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14521 PyObject *resultobj = NULL;
14522 wxImage_RGBValue arg1 ;
14523 wxImage_HSVValue result;
14524 PyObject * obj0 = 0 ;
14525 char *kwnames[] = {
14526 (char *) "rgb", NULL
14527 };
14528
14529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14530 {
14531 wxImage_RGBValue * argp;
14532 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14533 if (SWIG_arg_fail(1)) SWIG_fail;
14534 if (argp == NULL) {
14535 SWIG_null_ref("wxImage_RGBValue");
14536 }
14537 if (SWIG_arg_fail(1)) SWIG_fail;
14538 arg1 = *argp;
14539 }
14540 {
14541 PyThreadState* __tstate = wxPyBeginAllowThreads();
14542 result = wxImage::RGBtoHSV(arg1);
14543
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 {
14548 wxImage_HSVValue * resultptr;
14549 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14550 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14551 }
14552 return resultobj;
14553 fail:
14554 return NULL;
14555 }
14556
14557
14558 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14559 PyObject *resultobj = NULL;
14560 wxImage_HSVValue arg1 ;
14561 wxImage_RGBValue result;
14562 PyObject * obj0 = 0 ;
14563 char *kwnames[] = {
14564 (char *) "hsv", NULL
14565 };
14566
14567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14568 {
14569 wxImage_HSVValue * argp;
14570 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14571 if (SWIG_arg_fail(1)) SWIG_fail;
14572 if (argp == NULL) {
14573 SWIG_null_ref("wxImage_HSVValue");
14574 }
14575 if (SWIG_arg_fail(1)) SWIG_fail;
14576 arg1 = *argp;
14577 }
14578 {
14579 PyThreadState* __tstate = wxPyBeginAllowThreads();
14580 result = wxImage::HSVtoRGB(arg1);
14581
14582 wxPyEndAllowThreads(__tstate);
14583 if (PyErr_Occurred()) SWIG_fail;
14584 }
14585 {
14586 wxImage_RGBValue * resultptr;
14587 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14588 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14589 }
14590 return resultobj;
14591 fail:
14592 return NULL;
14593 }
14594
14595
14596 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14597 PyObject *obj;
14598 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14599 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14600 Py_INCREF(obj);
14601 return Py_BuildValue((char *)"");
14602 }
14603 static int _wrap_NullImage_set(PyObject *) {
14604 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14605 return 1;
14606 }
14607
14608
14609 static PyObject *_wrap_NullImage_get(void) {
14610 PyObject *pyobj = NULL;
14611
14612 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14613 return pyobj;
14614 }
14615
14616
14617 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14618 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14619 return 1;
14620 }
14621
14622
14623 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14624 PyObject *pyobj = NULL;
14625
14626 {
14627 #if wxUSE_UNICODE
14628 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14629 #else
14630 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14631 #endif
14632 }
14633 return pyobj;
14634 }
14635
14636
14637 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14638 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14639 return 1;
14640 }
14641
14642
14643 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14644 PyObject *pyobj = NULL;
14645
14646 {
14647 #if wxUSE_UNICODE
14648 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14649 #else
14650 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14651 #endif
14652 }
14653 return pyobj;
14654 }
14655
14656
14657 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14658 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14659 return 1;
14660 }
14661
14662
14663 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14664 PyObject *pyobj = NULL;
14665
14666 {
14667 #if wxUSE_UNICODE
14668 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14669 #else
14670 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14671 #endif
14672 }
14673 return pyobj;
14674 }
14675
14676
14677 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14678 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14679 return 1;
14680 }
14681
14682
14683 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14684 PyObject *pyobj = NULL;
14685
14686 {
14687 #if wxUSE_UNICODE
14688 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14689 #else
14690 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14691 #endif
14692 }
14693 return pyobj;
14694 }
14695
14696
14697 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14698 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14699 return 1;
14700 }
14701
14702
14703 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14704 PyObject *pyobj = NULL;
14705
14706 {
14707 #if wxUSE_UNICODE
14708 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14709 #else
14710 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14711 #endif
14712 }
14713 return pyobj;
14714 }
14715
14716
14717 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14718 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14719 return 1;
14720 }
14721
14722
14723 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14724 PyObject *pyobj = NULL;
14725
14726 {
14727 #if wxUSE_UNICODE
14728 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14729 #else
14730 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14731 #endif
14732 }
14733 return pyobj;
14734 }
14735
14736
14737 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14738 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14739 return 1;
14740 }
14741
14742
14743 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14744 PyObject *pyobj = NULL;
14745
14746 {
14747 #if wxUSE_UNICODE
14748 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14749 #else
14750 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14751 #endif
14752 }
14753 return pyobj;
14754 }
14755
14756
14757 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14758 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14759 return 1;
14760 }
14761
14762
14763 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14764 PyObject *pyobj = NULL;
14765
14766 {
14767 #if wxUSE_UNICODE
14768 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14769 #else
14770 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14771 #endif
14772 }
14773 return pyobj;
14774 }
14775
14776
14777 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14778 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14779 return 1;
14780 }
14781
14782
14783 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14784 PyObject *pyobj = NULL;
14785
14786 {
14787 #if wxUSE_UNICODE
14788 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14789 #else
14790 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14791 #endif
14792 }
14793 return pyobj;
14794 }
14795
14796
14797 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14798 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14799 return 1;
14800 }
14801
14802
14803 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14804 PyObject *pyobj = NULL;
14805
14806 {
14807 #if wxUSE_UNICODE
14808 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14809 #else
14810 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14811 #endif
14812 }
14813 return pyobj;
14814 }
14815
14816
14817 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14818 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14819 return 1;
14820 }
14821
14822
14823 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14824 PyObject *pyobj = NULL;
14825
14826 {
14827 #if wxUSE_UNICODE
14828 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14829 #else
14830 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14831 #endif
14832 }
14833 return pyobj;
14834 }
14835
14836
14837 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14838 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14839 return 1;
14840 }
14841
14842
14843 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14844 PyObject *pyobj = NULL;
14845
14846 {
14847 #if wxUSE_UNICODE
14848 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14849 #else
14850 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14851 #endif
14852 }
14853 return pyobj;
14854 }
14855
14856
14857 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14858 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14859 return 1;
14860 }
14861
14862
14863 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14864 PyObject *pyobj = NULL;
14865
14866 {
14867 #if wxUSE_UNICODE
14868 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14869 #else
14870 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14871 #endif
14872 }
14873 return pyobj;
14874 }
14875
14876
14877 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14878 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14879 return 1;
14880 }
14881
14882
14883 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14884 PyObject *pyobj = NULL;
14885
14886 {
14887 #if wxUSE_UNICODE
14888 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14889 #else
14890 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14891 #endif
14892 }
14893 return pyobj;
14894 }
14895
14896
14897 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14898 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14899 return 1;
14900 }
14901
14902
14903 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14904 PyObject *pyobj = NULL;
14905
14906 {
14907 #if wxUSE_UNICODE
14908 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14909 #else
14910 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14911 #endif
14912 }
14913 return pyobj;
14914 }
14915
14916
14917 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj = NULL;
14919 wxBMPHandler *result;
14920 char *kwnames[] = {
14921 NULL
14922 };
14923
14924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14925 {
14926 PyThreadState* __tstate = wxPyBeginAllowThreads();
14927 result = (wxBMPHandler *)new wxBMPHandler();
14928
14929 wxPyEndAllowThreads(__tstate);
14930 if (PyErr_Occurred()) SWIG_fail;
14931 }
14932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14933 return resultobj;
14934 fail:
14935 return NULL;
14936 }
14937
14938
14939 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14940 PyObject *obj;
14941 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14942 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14943 Py_INCREF(obj);
14944 return Py_BuildValue((char *)"");
14945 }
14946 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14947 PyObject *resultobj = NULL;
14948 wxICOHandler *result;
14949 char *kwnames[] = {
14950 NULL
14951 };
14952
14953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14954 {
14955 PyThreadState* __tstate = wxPyBeginAllowThreads();
14956 result = (wxICOHandler *)new wxICOHandler();
14957
14958 wxPyEndAllowThreads(__tstate);
14959 if (PyErr_Occurred()) SWIG_fail;
14960 }
14961 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14962 return resultobj;
14963 fail:
14964 return NULL;
14965 }
14966
14967
14968 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14969 PyObject *obj;
14970 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14971 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14972 Py_INCREF(obj);
14973 return Py_BuildValue((char *)"");
14974 }
14975 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14976 PyObject *resultobj = NULL;
14977 wxCURHandler *result;
14978 char *kwnames[] = {
14979 NULL
14980 };
14981
14982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14983 {
14984 PyThreadState* __tstate = wxPyBeginAllowThreads();
14985 result = (wxCURHandler *)new wxCURHandler();
14986
14987 wxPyEndAllowThreads(__tstate);
14988 if (PyErr_Occurred()) SWIG_fail;
14989 }
14990 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14991 return resultobj;
14992 fail:
14993 return NULL;
14994 }
14995
14996
14997 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14998 PyObject *obj;
14999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15000 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
15001 Py_INCREF(obj);
15002 return Py_BuildValue((char *)"");
15003 }
15004 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15005 PyObject *resultobj = NULL;
15006 wxANIHandler *result;
15007 char *kwnames[] = {
15008 NULL
15009 };
15010
15011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
15012 {
15013 PyThreadState* __tstate = wxPyBeginAllowThreads();
15014 result = (wxANIHandler *)new wxANIHandler();
15015
15016 wxPyEndAllowThreads(__tstate);
15017 if (PyErr_Occurred()) SWIG_fail;
15018 }
15019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
15020 return resultobj;
15021 fail:
15022 return NULL;
15023 }
15024
15025
15026 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15027 PyObject *obj;
15028 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15029 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15030 Py_INCREF(obj);
15031 return Py_BuildValue((char *)"");
15032 }
15033 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj = NULL;
15035 wxPNGHandler *result;
15036 char *kwnames[] = {
15037 NULL
15038 };
15039
15040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15041 {
15042 PyThreadState* __tstate = wxPyBeginAllowThreads();
15043 result = (wxPNGHandler *)new wxPNGHandler();
15044
15045 wxPyEndAllowThreads(__tstate);
15046 if (PyErr_Occurred()) SWIG_fail;
15047 }
15048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15049 return resultobj;
15050 fail:
15051 return NULL;
15052 }
15053
15054
15055 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15056 PyObject *obj;
15057 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15058 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15059 Py_INCREF(obj);
15060 return Py_BuildValue((char *)"");
15061 }
15062 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15063 PyObject *resultobj = NULL;
15064 wxGIFHandler *result;
15065 char *kwnames[] = {
15066 NULL
15067 };
15068
15069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15070 {
15071 PyThreadState* __tstate = wxPyBeginAllowThreads();
15072 result = (wxGIFHandler *)new wxGIFHandler();
15073
15074 wxPyEndAllowThreads(__tstate);
15075 if (PyErr_Occurred()) SWIG_fail;
15076 }
15077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15078 return resultobj;
15079 fail:
15080 return NULL;
15081 }
15082
15083
15084 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15085 PyObject *obj;
15086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15087 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15088 Py_INCREF(obj);
15089 return Py_BuildValue((char *)"");
15090 }
15091 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15092 PyObject *resultobj = NULL;
15093 wxPCXHandler *result;
15094 char *kwnames[] = {
15095 NULL
15096 };
15097
15098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15099 {
15100 PyThreadState* __tstate = wxPyBeginAllowThreads();
15101 result = (wxPCXHandler *)new wxPCXHandler();
15102
15103 wxPyEndAllowThreads(__tstate);
15104 if (PyErr_Occurred()) SWIG_fail;
15105 }
15106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15107 return resultobj;
15108 fail:
15109 return NULL;
15110 }
15111
15112
15113 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15114 PyObject *obj;
15115 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15116 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15117 Py_INCREF(obj);
15118 return Py_BuildValue((char *)"");
15119 }
15120 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj = NULL;
15122 wxJPEGHandler *result;
15123 char *kwnames[] = {
15124 NULL
15125 };
15126
15127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15128 {
15129 PyThreadState* __tstate = wxPyBeginAllowThreads();
15130 result = (wxJPEGHandler *)new wxJPEGHandler();
15131
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15143 PyObject *obj;
15144 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15145 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15146 Py_INCREF(obj);
15147 return Py_BuildValue((char *)"");
15148 }
15149 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15150 PyObject *resultobj = NULL;
15151 wxPNMHandler *result;
15152 char *kwnames[] = {
15153 NULL
15154 };
15155
15156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15157 {
15158 PyThreadState* __tstate = wxPyBeginAllowThreads();
15159 result = (wxPNMHandler *)new wxPNMHandler();
15160
15161 wxPyEndAllowThreads(__tstate);
15162 if (PyErr_Occurred()) SWIG_fail;
15163 }
15164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15165 return resultobj;
15166 fail:
15167 return NULL;
15168 }
15169
15170
15171 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15172 PyObject *obj;
15173 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15174 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15175 Py_INCREF(obj);
15176 return Py_BuildValue((char *)"");
15177 }
15178 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15179 PyObject *resultobj = NULL;
15180 wxXPMHandler *result;
15181 char *kwnames[] = {
15182 NULL
15183 };
15184
15185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15186 {
15187 PyThreadState* __tstate = wxPyBeginAllowThreads();
15188 result = (wxXPMHandler *)new wxXPMHandler();
15189
15190 wxPyEndAllowThreads(__tstate);
15191 if (PyErr_Occurred()) SWIG_fail;
15192 }
15193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15194 return resultobj;
15195 fail:
15196 return NULL;
15197 }
15198
15199
15200 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15201 PyObject *obj;
15202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15203 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15204 Py_INCREF(obj);
15205 return Py_BuildValue((char *)"");
15206 }
15207 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15208 PyObject *resultobj = NULL;
15209 wxTIFFHandler *result;
15210 char *kwnames[] = {
15211 NULL
15212 };
15213
15214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (wxTIFFHandler *)new wxTIFFHandler();
15218
15219 wxPyEndAllowThreads(__tstate);
15220 if (PyErr_Occurred()) SWIG_fail;
15221 }
15222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15223 return resultobj;
15224 fail:
15225 return NULL;
15226 }
15227
15228
15229 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15230 PyObject *obj;
15231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15232 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15233 Py_INCREF(obj);
15234 return Py_BuildValue((char *)"");
15235 }
15236 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15237 PyObject *resultobj = NULL;
15238 wxImage *arg1 = 0 ;
15239 wxImage *arg2 = 0 ;
15240 int arg3 = (int) 236 ;
15241 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15242 bool result;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 PyObject * obj2 = 0 ;
15246 PyObject * obj3 = 0 ;
15247 char *kwnames[] = {
15248 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15249 };
15250
15251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15252 {
15253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15254 if (SWIG_arg_fail(1)) SWIG_fail;
15255 if (arg1 == NULL) {
15256 SWIG_null_ref("wxImage");
15257 }
15258 if (SWIG_arg_fail(1)) SWIG_fail;
15259 }
15260 {
15261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15262 if (SWIG_arg_fail(2)) SWIG_fail;
15263 if (arg2 == NULL) {
15264 SWIG_null_ref("wxImage");
15265 }
15266 if (SWIG_arg_fail(2)) SWIG_fail;
15267 }
15268 if (obj2) {
15269 {
15270 arg3 = static_cast<int >(SWIG_As_int(obj2));
15271 if (SWIG_arg_fail(3)) SWIG_fail;
15272 }
15273 }
15274 if (obj3) {
15275 {
15276 arg4 = static_cast<int >(SWIG_As_int(obj3));
15277 if (SWIG_arg_fail(4)) SWIG_fail;
15278 }
15279 }
15280 {
15281 PyThreadState* __tstate = wxPyBeginAllowThreads();
15282 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15283
15284 wxPyEndAllowThreads(__tstate);
15285 if (PyErr_Occurred()) SWIG_fail;
15286 }
15287 {
15288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15289 }
15290 return resultobj;
15291 fail:
15292 return NULL;
15293 }
15294
15295
15296 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15297 PyObject *obj;
15298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15299 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15300 Py_INCREF(obj);
15301 return Py_BuildValue((char *)"");
15302 }
15303 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15304 PyObject *resultobj = NULL;
15305 wxEvtHandler *result;
15306 char *kwnames[] = {
15307 NULL
15308 };
15309
15310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15311 {
15312 PyThreadState* __tstate = wxPyBeginAllowThreads();
15313 result = (wxEvtHandler *)new wxEvtHandler();
15314
15315 wxPyEndAllowThreads(__tstate);
15316 if (PyErr_Occurred()) SWIG_fail;
15317 }
15318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15319 return resultobj;
15320 fail:
15321 return NULL;
15322 }
15323
15324
15325 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15326 PyObject *resultobj = NULL;
15327 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15328 wxEvtHandler *result;
15329 PyObject * obj0 = 0 ;
15330 char *kwnames[] = {
15331 (char *) "self", NULL
15332 };
15333
15334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15336 if (SWIG_arg_fail(1)) SWIG_fail;
15337 {
15338 PyThreadState* __tstate = wxPyBeginAllowThreads();
15339 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15340
15341 wxPyEndAllowThreads(__tstate);
15342 if (PyErr_Occurred()) SWIG_fail;
15343 }
15344 {
15345 resultobj = wxPyMake_wxObject(result, 0);
15346 }
15347 return resultobj;
15348 fail:
15349 return NULL;
15350 }
15351
15352
15353 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15354 PyObject *resultobj = NULL;
15355 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15356 wxEvtHandler *result;
15357 PyObject * obj0 = 0 ;
15358 char *kwnames[] = {
15359 (char *) "self", NULL
15360 };
15361
15362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15364 if (SWIG_arg_fail(1)) SWIG_fail;
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15368
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 {
15373 resultobj = wxPyMake_wxObject(result, 0);
15374 }
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15382 PyObject *resultobj = NULL;
15383 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15384 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15385 PyObject * obj0 = 0 ;
15386 PyObject * obj1 = 0 ;
15387 char *kwnames[] = {
15388 (char *) "self",(char *) "handler", NULL
15389 };
15390
15391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15393 if (SWIG_arg_fail(1)) SWIG_fail;
15394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15395 if (SWIG_arg_fail(2)) SWIG_fail;
15396 {
15397 PyThreadState* __tstate = wxPyBeginAllowThreads();
15398 (arg1)->SetNextHandler(arg2);
15399
15400 wxPyEndAllowThreads(__tstate);
15401 if (PyErr_Occurred()) SWIG_fail;
15402 }
15403 Py_INCREF(Py_None); resultobj = Py_None;
15404 return resultobj;
15405 fail:
15406 return NULL;
15407 }
15408
15409
15410 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15411 PyObject *resultobj = NULL;
15412 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15413 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15414 PyObject * obj0 = 0 ;
15415 PyObject * obj1 = 0 ;
15416 char *kwnames[] = {
15417 (char *) "self",(char *) "handler", NULL
15418 };
15419
15420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15422 if (SWIG_arg_fail(1)) SWIG_fail;
15423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(2)) SWIG_fail;
15425 {
15426 PyThreadState* __tstate = wxPyBeginAllowThreads();
15427 (arg1)->SetPreviousHandler(arg2);
15428
15429 wxPyEndAllowThreads(__tstate);
15430 if (PyErr_Occurred()) SWIG_fail;
15431 }
15432 Py_INCREF(Py_None); resultobj = Py_None;
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15440 PyObject *resultobj = NULL;
15441 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15442 bool result;
15443 PyObject * obj0 = 0 ;
15444 char *kwnames[] = {
15445 (char *) "self", NULL
15446 };
15447
15448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15450 if (SWIG_arg_fail(1)) SWIG_fail;
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (bool)(arg1)->GetEvtHandlerEnabled();
15454
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 {
15459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15460 }
15461 return resultobj;
15462 fail:
15463 return NULL;
15464 }
15465
15466
15467 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15468 PyObject *resultobj = NULL;
15469 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15470 bool arg2 ;
15471 PyObject * obj0 = 0 ;
15472 PyObject * obj1 = 0 ;
15473 char *kwnames[] = {
15474 (char *) "self",(char *) "enabled", NULL
15475 };
15476
15477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15479 if (SWIG_arg_fail(1)) SWIG_fail;
15480 {
15481 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15482 if (SWIG_arg_fail(2)) SWIG_fail;
15483 }
15484 {
15485 PyThreadState* __tstate = wxPyBeginAllowThreads();
15486 (arg1)->SetEvtHandlerEnabled(arg2);
15487
15488 wxPyEndAllowThreads(__tstate);
15489 if (PyErr_Occurred()) SWIG_fail;
15490 }
15491 Py_INCREF(Py_None); resultobj = Py_None;
15492 return resultobj;
15493 fail:
15494 return NULL;
15495 }
15496
15497
15498 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15499 PyObject *resultobj = NULL;
15500 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15501 wxEvent *arg2 = 0 ;
15502 bool result;
15503 PyObject * obj0 = 0 ;
15504 PyObject * obj1 = 0 ;
15505 char *kwnames[] = {
15506 (char *) "self",(char *) "event", NULL
15507 };
15508
15509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15514 if (SWIG_arg_fail(2)) SWIG_fail;
15515 if (arg2 == NULL) {
15516 SWIG_null_ref("wxEvent");
15517 }
15518 if (SWIG_arg_fail(2)) SWIG_fail;
15519 }
15520 {
15521 PyThreadState* __tstate = wxPyBeginAllowThreads();
15522 result = (bool)(arg1)->ProcessEvent(*arg2);
15523
15524 wxPyEndAllowThreads(__tstate);
15525 if (PyErr_Occurred()) SWIG_fail;
15526 }
15527 {
15528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15529 }
15530 return resultobj;
15531 fail:
15532 return NULL;
15533 }
15534
15535
15536 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15537 PyObject *resultobj = NULL;
15538 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15539 wxEvent *arg2 = 0 ;
15540 PyObject * obj0 = 0 ;
15541 PyObject * obj1 = 0 ;
15542 char *kwnames[] = {
15543 (char *) "self",(char *) "event", NULL
15544 };
15545
15546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15548 if (SWIG_arg_fail(1)) SWIG_fail;
15549 {
15550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15551 if (SWIG_arg_fail(2)) SWIG_fail;
15552 if (arg2 == NULL) {
15553 SWIG_null_ref("wxEvent");
15554 }
15555 if (SWIG_arg_fail(2)) SWIG_fail;
15556 }
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 (arg1)->AddPendingEvent(*arg2);
15560
15561 wxPyEndAllowThreads(__tstate);
15562 if (PyErr_Occurred()) SWIG_fail;
15563 }
15564 Py_INCREF(Py_None); resultobj = Py_None;
15565 return resultobj;
15566 fail:
15567 return NULL;
15568 }
15569
15570
15571 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15572 PyObject *resultobj = NULL;
15573 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15574 PyObject * obj0 = 0 ;
15575 char *kwnames[] = {
15576 (char *) "self", NULL
15577 };
15578
15579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15581 if (SWIG_arg_fail(1)) SWIG_fail;
15582 {
15583 PyThreadState* __tstate = wxPyBeginAllowThreads();
15584 (arg1)->ProcessPendingEvents();
15585
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 Py_INCREF(Py_None); resultobj = Py_None;
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15597 PyObject *resultobj = NULL;
15598 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15599 int arg2 ;
15600 int arg3 ;
15601 int arg4 ;
15602 PyObject *arg5 = (PyObject *) 0 ;
15603 PyObject * obj0 = 0 ;
15604 PyObject * obj1 = 0 ;
15605 PyObject * obj2 = 0 ;
15606 PyObject * obj3 = 0 ;
15607 PyObject * obj4 = 0 ;
15608 char *kwnames[] = {
15609 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15610 };
15611
15612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15614 if (SWIG_arg_fail(1)) SWIG_fail;
15615 {
15616 arg2 = static_cast<int >(SWIG_As_int(obj1));
15617 if (SWIG_arg_fail(2)) SWIG_fail;
15618 }
15619 {
15620 arg3 = static_cast<int >(SWIG_As_int(obj2));
15621 if (SWIG_arg_fail(3)) SWIG_fail;
15622 }
15623 {
15624 arg4 = static_cast<int >(SWIG_As_int(obj3));
15625 if (SWIG_arg_fail(4)) SWIG_fail;
15626 }
15627 arg5 = obj4;
15628 {
15629 PyThreadState* __tstate = wxPyBeginAllowThreads();
15630 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15631
15632 wxPyEndAllowThreads(__tstate);
15633 if (PyErr_Occurred()) SWIG_fail;
15634 }
15635 Py_INCREF(Py_None); resultobj = Py_None;
15636 return resultobj;
15637 fail:
15638 return NULL;
15639 }
15640
15641
15642 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15643 PyObject *resultobj = NULL;
15644 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15645 int arg2 ;
15646 int arg3 = (int) -1 ;
15647 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15648 bool result;
15649 PyObject * obj0 = 0 ;
15650 PyObject * obj1 = 0 ;
15651 PyObject * obj2 = 0 ;
15652 PyObject * obj3 = 0 ;
15653 char *kwnames[] = {
15654 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15655 };
15656
15657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15659 if (SWIG_arg_fail(1)) SWIG_fail;
15660 {
15661 arg2 = static_cast<int >(SWIG_As_int(obj1));
15662 if (SWIG_arg_fail(2)) SWIG_fail;
15663 }
15664 if (obj2) {
15665 {
15666 arg3 = static_cast<int >(SWIG_As_int(obj2));
15667 if (SWIG_arg_fail(3)) SWIG_fail;
15668 }
15669 }
15670 if (obj3) {
15671 {
15672 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15673 if (SWIG_arg_fail(4)) SWIG_fail;
15674 }
15675 }
15676 {
15677 PyThreadState* __tstate = wxPyBeginAllowThreads();
15678 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15679
15680 wxPyEndAllowThreads(__tstate);
15681 if (PyErr_Occurred()) SWIG_fail;
15682 }
15683 {
15684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15685 }
15686 return resultobj;
15687 fail:
15688 return NULL;
15689 }
15690
15691
15692 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15693 PyObject *resultobj = NULL;
15694 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15695 PyObject *arg2 = (PyObject *) 0 ;
15696 bool arg3 = (bool) true ;
15697 PyObject * obj0 = 0 ;
15698 PyObject * obj1 = 0 ;
15699 PyObject * obj2 = 0 ;
15700 char *kwnames[] = {
15701 (char *) "self",(char *) "_self",(char *) "incref", NULL
15702 };
15703
15704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15706 if (SWIG_arg_fail(1)) SWIG_fail;
15707 arg2 = obj1;
15708 if (obj2) {
15709 {
15710 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15711 if (SWIG_arg_fail(3)) SWIG_fail;
15712 }
15713 }
15714 {
15715 PyThreadState* __tstate = wxPyBeginAllowThreads();
15716 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15717
15718 wxPyEndAllowThreads(__tstate);
15719 if (PyErr_Occurred()) SWIG_fail;
15720 }
15721 Py_INCREF(Py_None); resultobj = Py_None;
15722 return resultobj;
15723 fail:
15724 return NULL;
15725 }
15726
15727
15728 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15729 PyObject *obj;
15730 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15731 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15732 Py_INCREF(obj);
15733 return Py_BuildValue((char *)"");
15734 }
15735 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15736 PyObject *resultobj = NULL;
15737 wxEventType result;
15738 char *kwnames[] = {
15739 NULL
15740 };
15741
15742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15743 {
15744 PyThreadState* __tstate = wxPyBeginAllowThreads();
15745 result = (wxEventType)wxNewEventType();
15746
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 {
15751 resultobj = SWIG_From_int(static_cast<int >(result));
15752 }
15753 return resultobj;
15754 fail:
15755 return NULL;
15756 }
15757
15758
15759 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15760 PyObject *resultobj = NULL;
15761 wxEvent *arg1 = (wxEvent *) 0 ;
15762 PyObject * obj0 = 0 ;
15763 char *kwnames[] = {
15764 (char *) "self", NULL
15765 };
15766
15767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15769 if (SWIG_arg_fail(1)) SWIG_fail;
15770 {
15771 PyThreadState* __tstate = wxPyBeginAllowThreads();
15772 delete arg1;
15773
15774 wxPyEndAllowThreads(__tstate);
15775 if (PyErr_Occurred()) SWIG_fail;
15776 }
15777 Py_INCREF(Py_None); resultobj = Py_None;
15778 return resultobj;
15779 fail:
15780 return NULL;
15781 }
15782
15783
15784 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15785 PyObject *resultobj = NULL;
15786 wxEvent *arg1 = (wxEvent *) 0 ;
15787 wxEventType arg2 ;
15788 PyObject * obj0 = 0 ;
15789 PyObject * obj1 = 0 ;
15790 char *kwnames[] = {
15791 (char *) "self",(char *) "typ", NULL
15792 };
15793
15794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15796 if (SWIG_arg_fail(1)) SWIG_fail;
15797 {
15798 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15799 if (SWIG_arg_fail(2)) SWIG_fail;
15800 }
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 (arg1)->SetEventType(arg2);
15804
15805 wxPyEndAllowThreads(__tstate);
15806 if (PyErr_Occurred()) SWIG_fail;
15807 }
15808 Py_INCREF(Py_None); resultobj = Py_None;
15809 return resultobj;
15810 fail:
15811 return NULL;
15812 }
15813
15814
15815 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15816 PyObject *resultobj = NULL;
15817 wxEvent *arg1 = (wxEvent *) 0 ;
15818 wxEventType result;
15819 PyObject * obj0 = 0 ;
15820 char *kwnames[] = {
15821 (char *) "self", NULL
15822 };
15823
15824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15826 if (SWIG_arg_fail(1)) SWIG_fail;
15827 {
15828 PyThreadState* __tstate = wxPyBeginAllowThreads();
15829 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15830
15831 wxPyEndAllowThreads(__tstate);
15832 if (PyErr_Occurred()) SWIG_fail;
15833 }
15834 {
15835 resultobj = SWIG_From_int(static_cast<int >(result));
15836 }
15837 return resultobj;
15838 fail:
15839 return NULL;
15840 }
15841
15842
15843 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15844 PyObject *resultobj = NULL;
15845 wxEvent *arg1 = (wxEvent *) 0 ;
15846 wxObject *result;
15847 PyObject * obj0 = 0 ;
15848 char *kwnames[] = {
15849 (char *) "self", NULL
15850 };
15851
15852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15854 if (SWIG_arg_fail(1)) SWIG_fail;
15855 {
15856 PyThreadState* __tstate = wxPyBeginAllowThreads();
15857 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15858
15859 wxPyEndAllowThreads(__tstate);
15860 if (PyErr_Occurred()) SWIG_fail;
15861 }
15862 {
15863 resultobj = wxPyMake_wxObject(result, (bool)0);
15864 }
15865 return resultobj;
15866 fail:
15867 return NULL;
15868 }
15869
15870
15871 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15872 PyObject *resultobj = NULL;
15873 wxEvent *arg1 = (wxEvent *) 0 ;
15874 wxObject *arg2 = (wxObject *) 0 ;
15875 PyObject * obj0 = 0 ;
15876 PyObject * obj1 = 0 ;
15877 char *kwnames[] = {
15878 (char *) "self",(char *) "obj", NULL
15879 };
15880
15881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15883 if (SWIG_arg_fail(1)) SWIG_fail;
15884 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15885 if (SWIG_arg_fail(2)) SWIG_fail;
15886 {
15887 PyThreadState* __tstate = wxPyBeginAllowThreads();
15888 (arg1)->SetEventObject(arg2);
15889
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 Py_INCREF(Py_None); resultobj = Py_None;
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj = NULL;
15902 wxEvent *arg1 = (wxEvent *) 0 ;
15903 long result;
15904 PyObject * obj0 = 0 ;
15905 char *kwnames[] = {
15906 (char *) "self", NULL
15907 };
15908
15909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15911 if (SWIG_arg_fail(1)) SWIG_fail;
15912 {
15913 PyThreadState* __tstate = wxPyBeginAllowThreads();
15914 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15915
15916 wxPyEndAllowThreads(__tstate);
15917 if (PyErr_Occurred()) SWIG_fail;
15918 }
15919 {
15920 resultobj = SWIG_From_long(static_cast<long >(result));
15921 }
15922 return resultobj;
15923 fail:
15924 return NULL;
15925 }
15926
15927
15928 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15929 PyObject *resultobj = NULL;
15930 wxEvent *arg1 = (wxEvent *) 0 ;
15931 long arg2 = (long) 0 ;
15932 PyObject * obj0 = 0 ;
15933 PyObject * obj1 = 0 ;
15934 char *kwnames[] = {
15935 (char *) "self",(char *) "ts", NULL
15936 };
15937
15938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15940 if (SWIG_arg_fail(1)) SWIG_fail;
15941 if (obj1) {
15942 {
15943 arg2 = static_cast<long >(SWIG_As_long(obj1));
15944 if (SWIG_arg_fail(2)) SWIG_fail;
15945 }
15946 }
15947 {
15948 PyThreadState* __tstate = wxPyBeginAllowThreads();
15949 (arg1)->SetTimestamp(arg2);
15950
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 Py_INCREF(Py_None); resultobj = Py_None;
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15962 PyObject *resultobj = NULL;
15963 wxEvent *arg1 = (wxEvent *) 0 ;
15964 int result;
15965 PyObject * obj0 = 0 ;
15966 char *kwnames[] = {
15967 (char *) "self", NULL
15968 };
15969
15970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) 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 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 result = (int)((wxEvent const *)arg1)->GetId();
15976
15977 wxPyEndAllowThreads(__tstate);
15978 if (PyErr_Occurred()) SWIG_fail;
15979 }
15980 {
15981 resultobj = SWIG_From_int(static_cast<int >(result));
15982 }
15983 return resultobj;
15984 fail:
15985 return NULL;
15986 }
15987
15988
15989 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15990 PyObject *resultobj = NULL;
15991 wxEvent *arg1 = (wxEvent *) 0 ;
15992 int arg2 ;
15993 PyObject * obj0 = 0 ;
15994 PyObject * obj1 = 0 ;
15995 char *kwnames[] = {
15996 (char *) "self",(char *) "Id", NULL
15997 };
15998
15999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
16000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16001 if (SWIG_arg_fail(1)) SWIG_fail;
16002 {
16003 arg2 = static_cast<int >(SWIG_As_int(obj1));
16004 if (SWIG_arg_fail(2)) SWIG_fail;
16005 }
16006 {
16007 PyThreadState* __tstate = wxPyBeginAllowThreads();
16008 (arg1)->SetId(arg2);
16009
16010 wxPyEndAllowThreads(__tstate);
16011 if (PyErr_Occurred()) SWIG_fail;
16012 }
16013 Py_INCREF(Py_None); resultobj = Py_None;
16014 return resultobj;
16015 fail:
16016 return NULL;
16017 }
16018
16019
16020 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16021 PyObject *resultobj = NULL;
16022 wxEvent *arg1 = (wxEvent *) 0 ;
16023 bool result;
16024 PyObject * obj0 = 0 ;
16025 char *kwnames[] = {
16026 (char *) "self", NULL
16027 };
16028
16029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16031 if (SWIG_arg_fail(1)) SWIG_fail;
16032 {
16033 PyThreadState* __tstate = wxPyBeginAllowThreads();
16034 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16035
16036 wxPyEndAllowThreads(__tstate);
16037 if (PyErr_Occurred()) SWIG_fail;
16038 }
16039 {
16040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16041 }
16042 return resultobj;
16043 fail:
16044 return NULL;
16045 }
16046
16047
16048 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16049 PyObject *resultobj = NULL;
16050 wxEvent *arg1 = (wxEvent *) 0 ;
16051 bool arg2 = (bool) true ;
16052 PyObject * obj0 = 0 ;
16053 PyObject * obj1 = 0 ;
16054 char *kwnames[] = {
16055 (char *) "self",(char *) "skip", NULL
16056 };
16057
16058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16060 if (SWIG_arg_fail(1)) SWIG_fail;
16061 if (obj1) {
16062 {
16063 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16064 if (SWIG_arg_fail(2)) SWIG_fail;
16065 }
16066 }
16067 {
16068 PyThreadState* __tstate = wxPyBeginAllowThreads();
16069 (arg1)->Skip(arg2);
16070
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 Py_INCREF(Py_None); resultobj = Py_None;
16075 return resultobj;
16076 fail:
16077 return NULL;
16078 }
16079
16080
16081 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16082 PyObject *resultobj = NULL;
16083 wxEvent *arg1 = (wxEvent *) 0 ;
16084 bool result;
16085 PyObject * obj0 = 0 ;
16086 char *kwnames[] = {
16087 (char *) "self", NULL
16088 };
16089
16090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) 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 {
16094 PyThreadState* __tstate = wxPyBeginAllowThreads();
16095 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16096
16097 wxPyEndAllowThreads(__tstate);
16098 if (PyErr_Occurred()) SWIG_fail;
16099 }
16100 {
16101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16102 }
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16110 PyObject *resultobj = NULL;
16111 wxEvent *arg1 = (wxEvent *) 0 ;
16112 bool result;
16113 PyObject * obj0 = 0 ;
16114 char *kwnames[] = {
16115 (char *) "self", NULL
16116 };
16117
16118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16120 if (SWIG_arg_fail(1)) SWIG_fail;
16121 {
16122 PyThreadState* __tstate = wxPyBeginAllowThreads();
16123 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16124
16125 wxPyEndAllowThreads(__tstate);
16126 if (PyErr_Occurred()) SWIG_fail;
16127 }
16128 {
16129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16130 }
16131 return resultobj;
16132 fail:
16133 return NULL;
16134 }
16135
16136
16137 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16138 PyObject *resultobj = NULL;
16139 wxEvent *arg1 = (wxEvent *) 0 ;
16140 int result;
16141 PyObject * obj0 = 0 ;
16142 char *kwnames[] = {
16143 (char *) "self", NULL
16144 };
16145
16146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16148 if (SWIG_arg_fail(1)) SWIG_fail;
16149 {
16150 PyThreadState* __tstate = wxPyBeginAllowThreads();
16151 result = (int)(arg1)->StopPropagation();
16152
16153 wxPyEndAllowThreads(__tstate);
16154 if (PyErr_Occurred()) SWIG_fail;
16155 }
16156 {
16157 resultobj = SWIG_From_int(static_cast<int >(result));
16158 }
16159 return resultobj;
16160 fail:
16161 return NULL;
16162 }
16163
16164
16165 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16166 PyObject *resultobj = NULL;
16167 wxEvent *arg1 = (wxEvent *) 0 ;
16168 int arg2 ;
16169 PyObject * obj0 = 0 ;
16170 PyObject * obj1 = 0 ;
16171 char *kwnames[] = {
16172 (char *) "self",(char *) "propagationLevel", NULL
16173 };
16174
16175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16177 if (SWIG_arg_fail(1)) SWIG_fail;
16178 {
16179 arg2 = static_cast<int >(SWIG_As_int(obj1));
16180 if (SWIG_arg_fail(2)) SWIG_fail;
16181 }
16182 {
16183 PyThreadState* __tstate = wxPyBeginAllowThreads();
16184 (arg1)->ResumePropagation(arg2);
16185
16186 wxPyEndAllowThreads(__tstate);
16187 if (PyErr_Occurred()) SWIG_fail;
16188 }
16189 Py_INCREF(Py_None); resultobj = Py_None;
16190 return resultobj;
16191 fail:
16192 return NULL;
16193 }
16194
16195
16196 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16197 PyObject *resultobj = NULL;
16198 wxEvent *arg1 = (wxEvent *) 0 ;
16199 wxEvent *result;
16200 PyObject * obj0 = 0 ;
16201 char *kwnames[] = {
16202 (char *) "self", NULL
16203 };
16204
16205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16207 if (SWIG_arg_fail(1)) SWIG_fail;
16208 {
16209 PyThreadState* __tstate = wxPyBeginAllowThreads();
16210 result = (wxEvent *)(arg1)->Clone();
16211
16212 wxPyEndAllowThreads(__tstate);
16213 if (PyErr_Occurred()) SWIG_fail;
16214 }
16215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16216 return resultobj;
16217 fail:
16218 return NULL;
16219 }
16220
16221
16222 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16223 PyObject *obj;
16224 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16225 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16226 Py_INCREF(obj);
16227 return Py_BuildValue((char *)"");
16228 }
16229 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj = NULL;
16231 wxEvent *arg1 = 0 ;
16232 wxPropagationDisabler *result;
16233 PyObject * obj0 = 0 ;
16234 char *kwnames[] = {
16235 (char *) "event", NULL
16236 };
16237
16238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16239 {
16240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16241 if (SWIG_arg_fail(1)) SWIG_fail;
16242 if (arg1 == NULL) {
16243 SWIG_null_ref("wxEvent");
16244 }
16245 if (SWIG_arg_fail(1)) SWIG_fail;
16246 }
16247 {
16248 PyThreadState* __tstate = wxPyBeginAllowThreads();
16249 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16250
16251 wxPyEndAllowThreads(__tstate);
16252 if (PyErr_Occurred()) SWIG_fail;
16253 }
16254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj = NULL;
16263 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16264 PyObject * obj0 = 0 ;
16265 char *kwnames[] = {
16266 (char *) "self", NULL
16267 };
16268
16269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16271 if (SWIG_arg_fail(1)) SWIG_fail;
16272 {
16273 PyThreadState* __tstate = wxPyBeginAllowThreads();
16274 delete arg1;
16275
16276 wxPyEndAllowThreads(__tstate);
16277 if (PyErr_Occurred()) SWIG_fail;
16278 }
16279 Py_INCREF(Py_None); resultobj = Py_None;
16280 return resultobj;
16281 fail:
16282 return NULL;
16283 }
16284
16285
16286 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16287 PyObject *obj;
16288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16289 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16290 Py_INCREF(obj);
16291 return Py_BuildValue((char *)"");
16292 }
16293 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16294 PyObject *resultobj = NULL;
16295 wxEvent *arg1 = 0 ;
16296 wxPropagateOnce *result;
16297 PyObject * obj0 = 0 ;
16298 char *kwnames[] = {
16299 (char *) "event", NULL
16300 };
16301
16302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16303 {
16304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16305 if (SWIG_arg_fail(1)) SWIG_fail;
16306 if (arg1 == NULL) {
16307 SWIG_null_ref("wxEvent");
16308 }
16309 if (SWIG_arg_fail(1)) SWIG_fail;
16310 }
16311 {
16312 PyThreadState* __tstate = wxPyBeginAllowThreads();
16313 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16314
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16319 return resultobj;
16320 fail:
16321 return NULL;
16322 }
16323
16324
16325 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16326 PyObject *resultobj = NULL;
16327 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16328 PyObject * obj0 = 0 ;
16329 char *kwnames[] = {
16330 (char *) "self", NULL
16331 };
16332
16333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16335 if (SWIG_arg_fail(1)) SWIG_fail;
16336 {
16337 PyThreadState* __tstate = wxPyBeginAllowThreads();
16338 delete arg1;
16339
16340 wxPyEndAllowThreads(__tstate);
16341 if (PyErr_Occurred()) SWIG_fail;
16342 }
16343 Py_INCREF(Py_None); resultobj = Py_None;
16344 return resultobj;
16345 fail:
16346 return NULL;
16347 }
16348
16349
16350 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16351 PyObject *obj;
16352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16353 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16354 Py_INCREF(obj);
16355 return Py_BuildValue((char *)"");
16356 }
16357 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = NULL;
16359 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16360 int arg2 = (int) 0 ;
16361 wxCommandEvent *result;
16362 PyObject * obj0 = 0 ;
16363 PyObject * obj1 = 0 ;
16364 char *kwnames[] = {
16365 (char *) "commandType",(char *) "winid", NULL
16366 };
16367
16368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16369 if (obj0) {
16370 {
16371 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16372 if (SWIG_arg_fail(1)) SWIG_fail;
16373 }
16374 }
16375 if (obj1) {
16376 {
16377 arg2 = static_cast<int >(SWIG_As_int(obj1));
16378 if (SWIG_arg_fail(2)) SWIG_fail;
16379 }
16380 }
16381 {
16382 PyThreadState* __tstate = wxPyBeginAllowThreads();
16383 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16384
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj = NULL;
16397 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16398 int result;
16399 PyObject * obj0 = 0 ;
16400 char *kwnames[] = {
16401 (char *) "self", NULL
16402 };
16403
16404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16406 if (SWIG_arg_fail(1)) SWIG_fail;
16407 {
16408 PyThreadState* __tstate = wxPyBeginAllowThreads();
16409 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16410
16411 wxPyEndAllowThreads(__tstate);
16412 if (PyErr_Occurred()) SWIG_fail;
16413 }
16414 {
16415 resultobj = SWIG_From_int(static_cast<int >(result));
16416 }
16417 return resultobj;
16418 fail:
16419 return NULL;
16420 }
16421
16422
16423 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16424 PyObject *resultobj = NULL;
16425 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16426 wxString *arg2 = 0 ;
16427 bool temp2 = false ;
16428 PyObject * obj0 = 0 ;
16429 PyObject * obj1 = 0 ;
16430 char *kwnames[] = {
16431 (char *) "self",(char *) "s", NULL
16432 };
16433
16434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16436 if (SWIG_arg_fail(1)) SWIG_fail;
16437 {
16438 arg2 = wxString_in_helper(obj1);
16439 if (arg2 == NULL) SWIG_fail;
16440 temp2 = true;
16441 }
16442 {
16443 PyThreadState* __tstate = wxPyBeginAllowThreads();
16444 (arg1)->SetString((wxString const &)*arg2);
16445
16446 wxPyEndAllowThreads(__tstate);
16447 if (PyErr_Occurred()) SWIG_fail;
16448 }
16449 Py_INCREF(Py_None); resultobj = Py_None;
16450 {
16451 if (temp2)
16452 delete arg2;
16453 }
16454 return resultobj;
16455 fail:
16456 {
16457 if (temp2)
16458 delete arg2;
16459 }
16460 return NULL;
16461 }
16462
16463
16464 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16465 PyObject *resultobj = NULL;
16466 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16467 wxString result;
16468 PyObject * obj0 = 0 ;
16469 char *kwnames[] = {
16470 (char *) "self", NULL
16471 };
16472
16473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16475 if (SWIG_arg_fail(1)) SWIG_fail;
16476 {
16477 PyThreadState* __tstate = wxPyBeginAllowThreads();
16478 result = ((wxCommandEvent const *)arg1)->GetString();
16479
16480 wxPyEndAllowThreads(__tstate);
16481 if (PyErr_Occurred()) SWIG_fail;
16482 }
16483 {
16484 #if wxUSE_UNICODE
16485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16486 #else
16487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16488 #endif
16489 }
16490 return resultobj;
16491 fail:
16492 return NULL;
16493 }
16494
16495
16496 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16497 PyObject *resultobj = NULL;
16498 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16499 bool result;
16500 PyObject * obj0 = 0 ;
16501 char *kwnames[] = {
16502 (char *) "self", NULL
16503 };
16504
16505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",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 = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16511
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 {
16516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16517 }
16518 return resultobj;
16519 fail:
16520 return NULL;
16521 }
16522
16523
16524 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16525 PyObject *resultobj = NULL;
16526 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16527 bool result;
16528 PyObject * obj0 = 0 ;
16529 char *kwnames[] = {
16530 (char *) "self", NULL
16531 };
16532
16533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16535 if (SWIG_arg_fail(1)) SWIG_fail;
16536 {
16537 PyThreadState* __tstate = wxPyBeginAllowThreads();
16538 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16539
16540 wxPyEndAllowThreads(__tstate);
16541 if (PyErr_Occurred()) SWIG_fail;
16542 }
16543 {
16544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16545 }
16546 return resultobj;
16547 fail:
16548 return NULL;
16549 }
16550
16551
16552 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16553 PyObject *resultobj = NULL;
16554 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16555 long arg2 ;
16556 PyObject * obj0 = 0 ;
16557 PyObject * obj1 = 0 ;
16558 char *kwnames[] = {
16559 (char *) "self",(char *) "extraLong", NULL
16560 };
16561
16562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16564 if (SWIG_arg_fail(1)) SWIG_fail;
16565 {
16566 arg2 = static_cast<long >(SWIG_As_long(obj1));
16567 if (SWIG_arg_fail(2)) SWIG_fail;
16568 }
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 (arg1)->SetExtraLong(arg2);
16572
16573 wxPyEndAllowThreads(__tstate);
16574 if (PyErr_Occurred()) SWIG_fail;
16575 }
16576 Py_INCREF(Py_None); resultobj = Py_None;
16577 return resultobj;
16578 fail:
16579 return NULL;
16580 }
16581
16582
16583 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16584 PyObject *resultobj = NULL;
16585 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16586 long result;
16587 PyObject * obj0 = 0 ;
16588 char *kwnames[] = {
16589 (char *) "self", NULL
16590 };
16591
16592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16594 if (SWIG_arg_fail(1)) SWIG_fail;
16595 {
16596 PyThreadState* __tstate = wxPyBeginAllowThreads();
16597 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16598
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 {
16603 resultobj = SWIG_From_long(static_cast<long >(result));
16604 }
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16612 PyObject *resultobj = NULL;
16613 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16614 int arg2 ;
16615 PyObject * obj0 = 0 ;
16616 PyObject * obj1 = 0 ;
16617 char *kwnames[] = {
16618 (char *) "self",(char *) "i", NULL
16619 };
16620
16621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16623 if (SWIG_arg_fail(1)) SWIG_fail;
16624 {
16625 arg2 = static_cast<int >(SWIG_As_int(obj1));
16626 if (SWIG_arg_fail(2)) SWIG_fail;
16627 }
16628 {
16629 PyThreadState* __tstate = wxPyBeginAllowThreads();
16630 (arg1)->SetInt(arg2);
16631
16632 wxPyEndAllowThreads(__tstate);
16633 if (PyErr_Occurred()) SWIG_fail;
16634 }
16635 Py_INCREF(Py_None); resultobj = Py_None;
16636 return resultobj;
16637 fail:
16638 return NULL;
16639 }
16640
16641
16642 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16643 PyObject *resultobj = NULL;
16644 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16645 long result;
16646 PyObject * obj0 = 0 ;
16647 char *kwnames[] = {
16648 (char *) "self", NULL
16649 };
16650
16651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16653 if (SWIG_arg_fail(1)) SWIG_fail;
16654 {
16655 PyThreadState* __tstate = wxPyBeginAllowThreads();
16656 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16657
16658 wxPyEndAllowThreads(__tstate);
16659 if (PyErr_Occurred()) SWIG_fail;
16660 }
16661 {
16662 resultobj = SWIG_From_long(static_cast<long >(result));
16663 }
16664 return resultobj;
16665 fail:
16666 return NULL;
16667 }
16668
16669
16670 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16671 PyObject *resultobj = NULL;
16672 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16673 wxEvent *result;
16674 PyObject * obj0 = 0 ;
16675 char *kwnames[] = {
16676 (char *) "self", NULL
16677 };
16678
16679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16681 if (SWIG_arg_fail(1)) SWIG_fail;
16682 {
16683 PyThreadState* __tstate = wxPyBeginAllowThreads();
16684 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16685
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16697 PyObject *obj;
16698 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16699 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16700 Py_INCREF(obj);
16701 return Py_BuildValue((char *)"");
16702 }
16703 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16704 PyObject *resultobj = NULL;
16705 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16706 int arg2 = (int) 0 ;
16707 wxNotifyEvent *result;
16708 PyObject * obj0 = 0 ;
16709 PyObject * obj1 = 0 ;
16710 char *kwnames[] = {
16711 (char *) "commandType",(char *) "winid", NULL
16712 };
16713
16714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16715 if (obj0) {
16716 {
16717 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16718 if (SWIG_arg_fail(1)) SWIG_fail;
16719 }
16720 }
16721 if (obj1) {
16722 {
16723 arg2 = static_cast<int >(SWIG_As_int(obj1));
16724 if (SWIG_arg_fail(2)) SWIG_fail;
16725 }
16726 }
16727 {
16728 PyThreadState* __tstate = wxPyBeginAllowThreads();
16729 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16730
16731 wxPyEndAllowThreads(__tstate);
16732 if (PyErr_Occurred()) SWIG_fail;
16733 }
16734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16735 return resultobj;
16736 fail:
16737 return NULL;
16738 }
16739
16740
16741 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16742 PyObject *resultobj = NULL;
16743 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16744 PyObject * obj0 = 0 ;
16745 char *kwnames[] = {
16746 (char *) "self", NULL
16747 };
16748
16749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16751 if (SWIG_arg_fail(1)) SWIG_fail;
16752 {
16753 PyThreadState* __tstate = wxPyBeginAllowThreads();
16754 (arg1)->Veto();
16755
16756 wxPyEndAllowThreads(__tstate);
16757 if (PyErr_Occurred()) SWIG_fail;
16758 }
16759 Py_INCREF(Py_None); resultobj = Py_None;
16760 return resultobj;
16761 fail:
16762 return NULL;
16763 }
16764
16765
16766 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16767 PyObject *resultobj = NULL;
16768 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16769 PyObject * obj0 = 0 ;
16770 char *kwnames[] = {
16771 (char *) "self", NULL
16772 };
16773
16774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16776 if (SWIG_arg_fail(1)) SWIG_fail;
16777 {
16778 PyThreadState* __tstate = wxPyBeginAllowThreads();
16779 (arg1)->Allow();
16780
16781 wxPyEndAllowThreads(__tstate);
16782 if (PyErr_Occurred()) SWIG_fail;
16783 }
16784 Py_INCREF(Py_None); resultobj = Py_None;
16785 return resultobj;
16786 fail:
16787 return NULL;
16788 }
16789
16790
16791 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16792 PyObject *resultobj = NULL;
16793 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16794 bool result;
16795 PyObject * obj0 = 0 ;
16796 char *kwnames[] = {
16797 (char *) "self", NULL
16798 };
16799
16800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16802 if (SWIG_arg_fail(1)) SWIG_fail;
16803 {
16804 PyThreadState* __tstate = wxPyBeginAllowThreads();
16805 result = (bool)(arg1)->IsAllowed();
16806
16807 wxPyEndAllowThreads(__tstate);
16808 if (PyErr_Occurred()) SWIG_fail;
16809 }
16810 {
16811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16812 }
16813 return resultobj;
16814 fail:
16815 return NULL;
16816 }
16817
16818
16819 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16820 PyObject *obj;
16821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16822 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16823 Py_INCREF(obj);
16824 return Py_BuildValue((char *)"");
16825 }
16826 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16827 PyObject *resultobj = NULL;
16828 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16829 int arg2 = (int) 0 ;
16830 int arg3 = (int) 0 ;
16831 int arg4 = (int) 0 ;
16832 wxScrollEvent *result;
16833 PyObject * obj0 = 0 ;
16834 PyObject * obj1 = 0 ;
16835 PyObject * obj2 = 0 ;
16836 PyObject * obj3 = 0 ;
16837 char *kwnames[] = {
16838 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16839 };
16840
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16842 if (obj0) {
16843 {
16844 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16845 if (SWIG_arg_fail(1)) SWIG_fail;
16846 }
16847 }
16848 if (obj1) {
16849 {
16850 arg2 = static_cast<int >(SWIG_As_int(obj1));
16851 if (SWIG_arg_fail(2)) SWIG_fail;
16852 }
16853 }
16854 if (obj2) {
16855 {
16856 arg3 = static_cast<int >(SWIG_As_int(obj2));
16857 if (SWIG_arg_fail(3)) SWIG_fail;
16858 }
16859 }
16860 if (obj3) {
16861 {
16862 arg4 = static_cast<int >(SWIG_As_int(obj3));
16863 if (SWIG_arg_fail(4)) SWIG_fail;
16864 }
16865 }
16866 {
16867 PyThreadState* __tstate = wxPyBeginAllowThreads();
16868 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16869
16870 wxPyEndAllowThreads(__tstate);
16871 if (PyErr_Occurred()) SWIG_fail;
16872 }
16873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16874 return resultobj;
16875 fail:
16876 return NULL;
16877 }
16878
16879
16880 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16881 PyObject *resultobj = NULL;
16882 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16883 int result;
16884 PyObject * obj0 = 0 ;
16885 char *kwnames[] = {
16886 (char *) "self", NULL
16887 };
16888
16889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16891 if (SWIG_arg_fail(1)) SWIG_fail;
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16895
16896 wxPyEndAllowThreads(__tstate);
16897 if (PyErr_Occurred()) SWIG_fail;
16898 }
16899 {
16900 resultobj = SWIG_From_int(static_cast<int >(result));
16901 }
16902 return resultobj;
16903 fail:
16904 return NULL;
16905 }
16906
16907
16908 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16909 PyObject *resultobj = NULL;
16910 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16911 int result;
16912 PyObject * obj0 = 0 ;
16913 char *kwnames[] = {
16914 (char *) "self", NULL
16915 };
16916
16917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16919 if (SWIG_arg_fail(1)) SWIG_fail;
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16923
16924 wxPyEndAllowThreads(__tstate);
16925 if (PyErr_Occurred()) SWIG_fail;
16926 }
16927 {
16928 resultobj = SWIG_From_int(static_cast<int >(result));
16929 }
16930 return resultobj;
16931 fail:
16932 return NULL;
16933 }
16934
16935
16936 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16937 PyObject *resultobj = NULL;
16938 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16939 int arg2 ;
16940 PyObject * obj0 = 0 ;
16941 PyObject * obj1 = 0 ;
16942 char *kwnames[] = {
16943 (char *) "self",(char *) "orient", NULL
16944 };
16945
16946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16948 if (SWIG_arg_fail(1)) SWIG_fail;
16949 {
16950 arg2 = static_cast<int >(SWIG_As_int(obj1));
16951 if (SWIG_arg_fail(2)) SWIG_fail;
16952 }
16953 {
16954 PyThreadState* __tstate = wxPyBeginAllowThreads();
16955 (arg1)->SetOrientation(arg2);
16956
16957 wxPyEndAllowThreads(__tstate);
16958 if (PyErr_Occurred()) SWIG_fail;
16959 }
16960 Py_INCREF(Py_None); resultobj = Py_None;
16961 return resultobj;
16962 fail:
16963 return NULL;
16964 }
16965
16966
16967 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16968 PyObject *resultobj = NULL;
16969 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16970 int arg2 ;
16971 PyObject * obj0 = 0 ;
16972 PyObject * obj1 = 0 ;
16973 char *kwnames[] = {
16974 (char *) "self",(char *) "pos", NULL
16975 };
16976
16977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16979 if (SWIG_arg_fail(1)) SWIG_fail;
16980 {
16981 arg2 = static_cast<int >(SWIG_As_int(obj1));
16982 if (SWIG_arg_fail(2)) SWIG_fail;
16983 }
16984 {
16985 PyThreadState* __tstate = wxPyBeginAllowThreads();
16986 (arg1)->SetPosition(arg2);
16987
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 Py_INCREF(Py_None); resultobj = Py_None;
16992 return resultobj;
16993 fail:
16994 return NULL;
16995 }
16996
16997
16998 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16999 PyObject *obj;
17000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17001 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
17002 Py_INCREF(obj);
17003 return Py_BuildValue((char *)"");
17004 }
17005 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17006 PyObject *resultobj = NULL;
17007 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17008 int arg2 = (int) 0 ;
17009 int arg3 = (int) 0 ;
17010 wxScrollWinEvent *result;
17011 PyObject * obj0 = 0 ;
17012 PyObject * obj1 = 0 ;
17013 PyObject * obj2 = 0 ;
17014 char *kwnames[] = {
17015 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
17016 };
17017
17018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
17019 if (obj0) {
17020 {
17021 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17022 if (SWIG_arg_fail(1)) SWIG_fail;
17023 }
17024 }
17025 if (obj1) {
17026 {
17027 arg2 = static_cast<int >(SWIG_As_int(obj1));
17028 if (SWIG_arg_fail(2)) SWIG_fail;
17029 }
17030 }
17031 if (obj2) {
17032 {
17033 arg3 = static_cast<int >(SWIG_As_int(obj2));
17034 if (SWIG_arg_fail(3)) SWIG_fail;
17035 }
17036 }
17037 {
17038 PyThreadState* __tstate = wxPyBeginAllowThreads();
17039 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17040
17041 wxPyEndAllowThreads(__tstate);
17042 if (PyErr_Occurred()) SWIG_fail;
17043 }
17044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17045 return resultobj;
17046 fail:
17047 return NULL;
17048 }
17049
17050
17051 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17052 PyObject *resultobj = NULL;
17053 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17054 int result;
17055 PyObject * obj0 = 0 ;
17056 char *kwnames[] = {
17057 (char *) "self", NULL
17058 };
17059
17060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17062 if (SWIG_arg_fail(1)) SWIG_fail;
17063 {
17064 PyThreadState* __tstate = wxPyBeginAllowThreads();
17065 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17066
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 {
17071 resultobj = SWIG_From_int(static_cast<int >(result));
17072 }
17073 return resultobj;
17074 fail:
17075 return NULL;
17076 }
17077
17078
17079 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17080 PyObject *resultobj = NULL;
17081 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17082 int result;
17083 PyObject * obj0 = 0 ;
17084 char *kwnames[] = {
17085 (char *) "self", NULL
17086 };
17087
17088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17090 if (SWIG_arg_fail(1)) SWIG_fail;
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17094
17095 wxPyEndAllowThreads(__tstate);
17096 if (PyErr_Occurred()) SWIG_fail;
17097 }
17098 {
17099 resultobj = SWIG_From_int(static_cast<int >(result));
17100 }
17101 return resultobj;
17102 fail:
17103 return NULL;
17104 }
17105
17106
17107 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj = NULL;
17109 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17110 int arg2 ;
17111 PyObject * obj0 = 0 ;
17112 PyObject * obj1 = 0 ;
17113 char *kwnames[] = {
17114 (char *) "self",(char *) "orient", NULL
17115 };
17116
17117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17119 if (SWIG_arg_fail(1)) SWIG_fail;
17120 {
17121 arg2 = static_cast<int >(SWIG_As_int(obj1));
17122 if (SWIG_arg_fail(2)) SWIG_fail;
17123 }
17124 {
17125 PyThreadState* __tstate = wxPyBeginAllowThreads();
17126 (arg1)->SetOrientation(arg2);
17127
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 Py_INCREF(Py_None); resultobj = Py_None;
17132 return resultobj;
17133 fail:
17134 return NULL;
17135 }
17136
17137
17138 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17139 PyObject *resultobj = NULL;
17140 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17141 int arg2 ;
17142 PyObject * obj0 = 0 ;
17143 PyObject * obj1 = 0 ;
17144 char *kwnames[] = {
17145 (char *) "self",(char *) "pos", NULL
17146 };
17147
17148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17150 if (SWIG_arg_fail(1)) SWIG_fail;
17151 {
17152 arg2 = static_cast<int >(SWIG_As_int(obj1));
17153 if (SWIG_arg_fail(2)) SWIG_fail;
17154 }
17155 {
17156 PyThreadState* __tstate = wxPyBeginAllowThreads();
17157 (arg1)->SetPosition(arg2);
17158
17159 wxPyEndAllowThreads(__tstate);
17160 if (PyErr_Occurred()) SWIG_fail;
17161 }
17162 Py_INCREF(Py_None); resultobj = Py_None;
17163 return resultobj;
17164 fail:
17165 return NULL;
17166 }
17167
17168
17169 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17170 PyObject *obj;
17171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17172 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17173 Py_INCREF(obj);
17174 return Py_BuildValue((char *)"");
17175 }
17176 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17177 PyObject *resultobj = NULL;
17178 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17179 wxMouseEvent *result;
17180 PyObject * obj0 = 0 ;
17181 char *kwnames[] = {
17182 (char *) "mouseType", NULL
17183 };
17184
17185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17186 if (obj0) {
17187 {
17188 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17189 if (SWIG_arg_fail(1)) SWIG_fail;
17190 }
17191 }
17192 {
17193 PyThreadState* __tstate = wxPyBeginAllowThreads();
17194 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17195
17196 wxPyEndAllowThreads(__tstate);
17197 if (PyErr_Occurred()) SWIG_fail;
17198 }
17199 {
17200 resultobj = wxPyMake_wxObject(result, (bool)1);
17201 }
17202 return resultobj;
17203 fail:
17204 return NULL;
17205 }
17206
17207
17208 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17209 PyObject *resultobj = NULL;
17210 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17211 bool result;
17212 PyObject * obj0 = 0 ;
17213 char *kwnames[] = {
17214 (char *) "self", NULL
17215 };
17216
17217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17219 if (SWIG_arg_fail(1)) SWIG_fail;
17220 {
17221 PyThreadState* __tstate = wxPyBeginAllowThreads();
17222 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17223
17224 wxPyEndAllowThreads(__tstate);
17225 if (PyErr_Occurred()) SWIG_fail;
17226 }
17227 {
17228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17229 }
17230 return resultobj;
17231 fail:
17232 return NULL;
17233 }
17234
17235
17236 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17237 PyObject *resultobj = NULL;
17238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17239 int arg2 = (int) wxMOUSE_BTN_ANY ;
17240 bool result;
17241 PyObject * obj0 = 0 ;
17242 PyObject * obj1 = 0 ;
17243 char *kwnames[] = {
17244 (char *) "self",(char *) "but", NULL
17245 };
17246
17247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17249 if (SWIG_arg_fail(1)) SWIG_fail;
17250 if (obj1) {
17251 {
17252 arg2 = static_cast<int >(SWIG_As_int(obj1));
17253 if (SWIG_arg_fail(2)) SWIG_fail;
17254 }
17255 }
17256 {
17257 PyThreadState* __tstate = wxPyBeginAllowThreads();
17258 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17259
17260 wxPyEndAllowThreads(__tstate);
17261 if (PyErr_Occurred()) SWIG_fail;
17262 }
17263 {
17264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17265 }
17266 return resultobj;
17267 fail:
17268 return NULL;
17269 }
17270
17271
17272 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17273 PyObject *resultobj = NULL;
17274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17275 int arg2 = (int) wxMOUSE_BTN_ANY ;
17276 bool result;
17277 PyObject * obj0 = 0 ;
17278 PyObject * obj1 = 0 ;
17279 char *kwnames[] = {
17280 (char *) "self",(char *) "but", NULL
17281 };
17282
17283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17285 if (SWIG_arg_fail(1)) SWIG_fail;
17286 if (obj1) {
17287 {
17288 arg2 = static_cast<int >(SWIG_As_int(obj1));
17289 if (SWIG_arg_fail(2)) SWIG_fail;
17290 }
17291 }
17292 {
17293 PyThreadState* __tstate = wxPyBeginAllowThreads();
17294 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17295
17296 wxPyEndAllowThreads(__tstate);
17297 if (PyErr_Occurred()) SWIG_fail;
17298 }
17299 {
17300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17301 }
17302 return resultobj;
17303 fail:
17304 return NULL;
17305 }
17306
17307
17308 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17309 PyObject *resultobj = NULL;
17310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17311 int arg2 = (int) wxMOUSE_BTN_ANY ;
17312 bool result;
17313 PyObject * obj0 = 0 ;
17314 PyObject * obj1 = 0 ;
17315 char *kwnames[] = {
17316 (char *) "self",(char *) "but", NULL
17317 };
17318
17319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17321 if (SWIG_arg_fail(1)) SWIG_fail;
17322 if (obj1) {
17323 {
17324 arg2 = static_cast<int >(SWIG_As_int(obj1));
17325 if (SWIG_arg_fail(2)) SWIG_fail;
17326 }
17327 }
17328 {
17329 PyThreadState* __tstate = wxPyBeginAllowThreads();
17330 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17331
17332 wxPyEndAllowThreads(__tstate);
17333 if (PyErr_Occurred()) SWIG_fail;
17334 }
17335 {
17336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17337 }
17338 return resultobj;
17339 fail:
17340 return NULL;
17341 }
17342
17343
17344 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17345 PyObject *resultobj = NULL;
17346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17347 int arg2 ;
17348 bool result;
17349 PyObject * obj0 = 0 ;
17350 PyObject * obj1 = 0 ;
17351 char *kwnames[] = {
17352 (char *) "self",(char *) "button", NULL
17353 };
17354
17355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17357 if (SWIG_arg_fail(1)) SWIG_fail;
17358 {
17359 arg2 = static_cast<int >(SWIG_As_int(obj1));
17360 if (SWIG_arg_fail(2)) SWIG_fail;
17361 }
17362 {
17363 PyThreadState* __tstate = wxPyBeginAllowThreads();
17364 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17365
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 {
17370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17371 }
17372 return resultobj;
17373 fail:
17374 return NULL;
17375 }
17376
17377
17378 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17379 PyObject *resultobj = NULL;
17380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17381 int arg2 ;
17382 bool result;
17383 PyObject * obj0 = 0 ;
17384 PyObject * obj1 = 0 ;
17385 char *kwnames[] = {
17386 (char *) "self",(char *) "but", NULL
17387 };
17388
17389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17391 if (SWIG_arg_fail(1)) SWIG_fail;
17392 {
17393 arg2 = static_cast<int >(SWIG_As_int(obj1));
17394 if (SWIG_arg_fail(2)) SWIG_fail;
17395 }
17396 {
17397 PyThreadState* __tstate = wxPyBeginAllowThreads();
17398 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17399
17400 wxPyEndAllowThreads(__tstate);
17401 if (PyErr_Occurred()) SWIG_fail;
17402 }
17403 {
17404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17405 }
17406 return resultobj;
17407 fail:
17408 return NULL;
17409 }
17410
17411
17412 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17413 PyObject *resultobj = NULL;
17414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17415 int result;
17416 PyObject * obj0 = 0 ;
17417 char *kwnames[] = {
17418 (char *) "self", NULL
17419 };
17420
17421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
17426 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17427
17428 wxPyEndAllowThreads(__tstate);
17429 if (PyErr_Occurred()) SWIG_fail;
17430 }
17431 {
17432 resultobj = SWIG_From_int(static_cast<int >(result));
17433 }
17434 return resultobj;
17435 fail:
17436 return NULL;
17437 }
17438
17439
17440 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj = NULL;
17442 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17443 bool result;
17444 PyObject * obj0 = 0 ;
17445 char *kwnames[] = {
17446 (char *) "self", NULL
17447 };
17448
17449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17451 if (SWIG_arg_fail(1)) SWIG_fail;
17452 {
17453 PyThreadState* __tstate = wxPyBeginAllowThreads();
17454 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17455
17456 wxPyEndAllowThreads(__tstate);
17457 if (PyErr_Occurred()) SWIG_fail;
17458 }
17459 {
17460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17461 }
17462 return resultobj;
17463 fail:
17464 return NULL;
17465 }
17466
17467
17468 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17469 PyObject *resultobj = NULL;
17470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17471 bool result;
17472 PyObject * obj0 = 0 ;
17473 char *kwnames[] = {
17474 (char *) "self", NULL
17475 };
17476
17477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17479 if (SWIG_arg_fail(1)) SWIG_fail;
17480 {
17481 PyThreadState* __tstate = wxPyBeginAllowThreads();
17482 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17483
17484 wxPyEndAllowThreads(__tstate);
17485 if (PyErr_Occurred()) SWIG_fail;
17486 }
17487 {
17488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17489 }
17490 return resultobj;
17491 fail:
17492 return NULL;
17493 }
17494
17495
17496 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17497 PyObject *resultobj = NULL;
17498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17499 bool result;
17500 PyObject * obj0 = 0 ;
17501 char *kwnames[] = {
17502 (char *) "self", NULL
17503 };
17504
17505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17507 if (SWIG_arg_fail(1)) SWIG_fail;
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17511
17512 wxPyEndAllowThreads(__tstate);
17513 if (PyErr_Occurred()) SWIG_fail;
17514 }
17515 {
17516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17517 }
17518 return resultobj;
17519 fail:
17520 return NULL;
17521 }
17522
17523
17524 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17525 PyObject *resultobj = NULL;
17526 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17527 bool result;
17528 PyObject * obj0 = 0 ;
17529 char *kwnames[] = {
17530 (char *) "self", NULL
17531 };
17532
17533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17535 if (SWIG_arg_fail(1)) SWIG_fail;
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17539
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 {
17544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17545 }
17546 return resultobj;
17547 fail:
17548 return NULL;
17549 }
17550
17551
17552 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17553 PyObject *resultobj = NULL;
17554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17555 bool result;
17556 PyObject * obj0 = 0 ;
17557 char *kwnames[] = {
17558 (char *) "self", NULL
17559 };
17560
17561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17563 if (SWIG_arg_fail(1)) SWIG_fail;
17564 {
17565 PyThreadState* __tstate = wxPyBeginAllowThreads();
17566 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17567
17568 wxPyEndAllowThreads(__tstate);
17569 if (PyErr_Occurred()) SWIG_fail;
17570 }
17571 {
17572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17573 }
17574 return resultobj;
17575 fail:
17576 return NULL;
17577 }
17578
17579
17580 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17581 PyObject *resultobj = NULL;
17582 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17583 bool result;
17584 PyObject * obj0 = 0 ;
17585 char *kwnames[] = {
17586 (char *) "self", NULL
17587 };
17588
17589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17591 if (SWIG_arg_fail(1)) SWIG_fail;
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17595
17596 wxPyEndAllowThreads(__tstate);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 }
17599 {
17600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17601 }
17602 return resultobj;
17603 fail:
17604 return NULL;
17605 }
17606
17607
17608 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17609 PyObject *resultobj = NULL;
17610 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17611 bool result;
17612 PyObject * obj0 = 0 ;
17613 char *kwnames[] = {
17614 (char *) "self", NULL
17615 };
17616
17617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17619 if (SWIG_arg_fail(1)) SWIG_fail;
17620 {
17621 PyThreadState* __tstate = wxPyBeginAllowThreads();
17622 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17623
17624 wxPyEndAllowThreads(__tstate);
17625 if (PyErr_Occurred()) SWIG_fail;
17626 }
17627 {
17628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17629 }
17630 return resultobj;
17631 fail:
17632 return NULL;
17633 }
17634
17635
17636 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17637 PyObject *resultobj = NULL;
17638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17639 bool result;
17640 PyObject * obj0 = 0 ;
17641 char *kwnames[] = {
17642 (char *) "self", NULL
17643 };
17644
17645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17647 if (SWIG_arg_fail(1)) SWIG_fail;
17648 {
17649 PyThreadState* __tstate = wxPyBeginAllowThreads();
17650 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17651
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 {
17656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17657 }
17658 return resultobj;
17659 fail:
17660 return NULL;
17661 }
17662
17663
17664 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17665 PyObject *resultobj = NULL;
17666 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17667 bool result;
17668 PyObject * obj0 = 0 ;
17669 char *kwnames[] = {
17670 (char *) "self", NULL
17671 };
17672
17673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17675 if (SWIG_arg_fail(1)) SWIG_fail;
17676 {
17677 PyThreadState* __tstate = wxPyBeginAllowThreads();
17678 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17679
17680 wxPyEndAllowThreads(__tstate);
17681 if (PyErr_Occurred()) SWIG_fail;
17682 }
17683 {
17684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17685 }
17686 return resultobj;
17687 fail:
17688 return NULL;
17689 }
17690
17691
17692 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17693 PyObject *resultobj = NULL;
17694 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17695 bool result;
17696 PyObject * obj0 = 0 ;
17697 char *kwnames[] = {
17698 (char *) "self", NULL
17699 };
17700
17701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17703 if (SWIG_arg_fail(1)) SWIG_fail;
17704 {
17705 PyThreadState* __tstate = wxPyBeginAllowThreads();
17706 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17707
17708 wxPyEndAllowThreads(__tstate);
17709 if (PyErr_Occurred()) SWIG_fail;
17710 }
17711 {
17712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj = NULL;
17722 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17723 bool result;
17724 PyObject * obj0 = 0 ;
17725 char *kwnames[] = {
17726 (char *) "self", NULL
17727 };
17728
17729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17731 if (SWIG_arg_fail(1)) SWIG_fail;
17732 {
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17735
17736 wxPyEndAllowThreads(__tstate);
17737 if (PyErr_Occurred()) SWIG_fail;
17738 }
17739 {
17740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17741 }
17742 return resultobj;
17743 fail:
17744 return NULL;
17745 }
17746
17747
17748 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj = NULL;
17750 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17751 bool result;
17752 PyObject * obj0 = 0 ;
17753 char *kwnames[] = {
17754 (char *) "self", NULL
17755 };
17756
17757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17759 if (SWIG_arg_fail(1)) SWIG_fail;
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17763
17764 wxPyEndAllowThreads(__tstate);
17765 if (PyErr_Occurred()) SWIG_fail;
17766 }
17767 {
17768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17769 }
17770 return resultobj;
17771 fail:
17772 return NULL;
17773 }
17774
17775
17776 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17777 PyObject *resultobj = NULL;
17778 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17779 bool result;
17780 PyObject * obj0 = 0 ;
17781 char *kwnames[] = {
17782 (char *) "self", NULL
17783 };
17784
17785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17787 if (SWIG_arg_fail(1)) SWIG_fail;
17788 {
17789 PyThreadState* __tstate = wxPyBeginAllowThreads();
17790 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17791
17792 wxPyEndAllowThreads(__tstate);
17793 if (PyErr_Occurred()) SWIG_fail;
17794 }
17795 {
17796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17797 }
17798 return resultobj;
17799 fail:
17800 return NULL;
17801 }
17802
17803
17804 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj = NULL;
17806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17807 bool result;
17808 PyObject * obj0 = 0 ;
17809 char *kwnames[] = {
17810 (char *) "self", NULL
17811 };
17812
17813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17815 if (SWIG_arg_fail(1)) SWIG_fail;
17816 {
17817 PyThreadState* __tstate = wxPyBeginAllowThreads();
17818 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17819
17820 wxPyEndAllowThreads(__tstate);
17821 if (PyErr_Occurred()) SWIG_fail;
17822 }
17823 {
17824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17825 }
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17833 PyObject *resultobj = NULL;
17834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17835 bool result;
17836 PyObject * obj0 = 0 ;
17837 char *kwnames[] = {
17838 (char *) "self", NULL
17839 };
17840
17841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17843 if (SWIG_arg_fail(1)) SWIG_fail;
17844 {
17845 PyThreadState* __tstate = wxPyBeginAllowThreads();
17846 result = (bool)(arg1)->LeftIsDown();
17847
17848 wxPyEndAllowThreads(__tstate);
17849 if (PyErr_Occurred()) SWIG_fail;
17850 }
17851 {
17852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17853 }
17854 return resultobj;
17855 fail:
17856 return NULL;
17857 }
17858
17859
17860 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17861 PyObject *resultobj = NULL;
17862 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17863 bool result;
17864 PyObject * obj0 = 0 ;
17865 char *kwnames[] = {
17866 (char *) "self", NULL
17867 };
17868
17869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17871 if (SWIG_arg_fail(1)) SWIG_fail;
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 result = (bool)(arg1)->MiddleIsDown();
17875
17876 wxPyEndAllowThreads(__tstate);
17877 if (PyErr_Occurred()) SWIG_fail;
17878 }
17879 {
17880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17881 }
17882 return resultobj;
17883 fail:
17884 return NULL;
17885 }
17886
17887
17888 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17889 PyObject *resultobj = NULL;
17890 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17891 bool result;
17892 PyObject * obj0 = 0 ;
17893 char *kwnames[] = {
17894 (char *) "self", NULL
17895 };
17896
17897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17899 if (SWIG_arg_fail(1)) SWIG_fail;
17900 {
17901 PyThreadState* __tstate = wxPyBeginAllowThreads();
17902 result = (bool)(arg1)->RightIsDown();
17903
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 {
17908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17909 }
17910 return resultobj;
17911 fail:
17912 return NULL;
17913 }
17914
17915
17916 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17917 PyObject *resultobj = NULL;
17918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17919 bool result;
17920 PyObject * obj0 = 0 ;
17921 char *kwnames[] = {
17922 (char *) "self", NULL
17923 };
17924
17925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17927 if (SWIG_arg_fail(1)) SWIG_fail;
17928 {
17929 PyThreadState* __tstate = wxPyBeginAllowThreads();
17930 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17931
17932 wxPyEndAllowThreads(__tstate);
17933 if (PyErr_Occurred()) SWIG_fail;
17934 }
17935 {
17936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17937 }
17938 return resultobj;
17939 fail:
17940 return NULL;
17941 }
17942
17943
17944 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17945 PyObject *resultobj = NULL;
17946 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17947 bool result;
17948 PyObject * obj0 = 0 ;
17949 char *kwnames[] = {
17950 (char *) "self", NULL
17951 };
17952
17953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17955 if (SWIG_arg_fail(1)) SWIG_fail;
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17959
17960 wxPyEndAllowThreads(__tstate);
17961 if (PyErr_Occurred()) SWIG_fail;
17962 }
17963 {
17964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17965 }
17966 return resultobj;
17967 fail:
17968 return NULL;
17969 }
17970
17971
17972 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17973 PyObject *resultobj = NULL;
17974 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17975 bool result;
17976 PyObject * obj0 = 0 ;
17977 char *kwnames[] = {
17978 (char *) "self", NULL
17979 };
17980
17981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17983 if (SWIG_arg_fail(1)) SWIG_fail;
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17987
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 {
17992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17993 }
17994 return resultobj;
17995 fail:
17996 return NULL;
17997 }
17998
17999
18000 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
18001 PyObject *resultobj = NULL;
18002 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18003 bool result;
18004 PyObject * obj0 = 0 ;
18005 char *kwnames[] = {
18006 (char *) "self", NULL
18007 };
18008
18009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
18010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18011 if (SWIG_arg_fail(1)) SWIG_fail;
18012 {
18013 PyThreadState* __tstate = wxPyBeginAllowThreads();
18014 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
18015
18016 wxPyEndAllowThreads(__tstate);
18017 if (PyErr_Occurred()) SWIG_fail;
18018 }
18019 {
18020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18021 }
18022 return resultobj;
18023 fail:
18024 return NULL;
18025 }
18026
18027
18028 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18029 PyObject *resultobj = NULL;
18030 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18031 wxPoint result;
18032 PyObject * obj0 = 0 ;
18033 char *kwnames[] = {
18034 (char *) "self", NULL
18035 };
18036
18037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18039 if (SWIG_arg_fail(1)) SWIG_fail;
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 result = (arg1)->GetPosition();
18043
18044 wxPyEndAllowThreads(__tstate);
18045 if (PyErr_Occurred()) SWIG_fail;
18046 }
18047 {
18048 wxPoint * resultptr;
18049 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18051 }
18052 return resultobj;
18053 fail:
18054 return NULL;
18055 }
18056
18057
18058 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18059 PyObject *resultobj = NULL;
18060 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18061 long *arg2 = (long *) 0 ;
18062 long *arg3 = (long *) 0 ;
18063 long temp2 ;
18064 int res2 = 0 ;
18065 long temp3 ;
18066 int res3 = 0 ;
18067 PyObject * obj0 = 0 ;
18068 char *kwnames[] = {
18069 (char *) "self", NULL
18070 };
18071
18072 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18073 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18076 if (SWIG_arg_fail(1)) SWIG_fail;
18077 {
18078 PyThreadState* __tstate = wxPyBeginAllowThreads();
18079 (arg1)->GetPosition(arg2,arg3);
18080
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 Py_INCREF(Py_None); resultobj = Py_None;
18085 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18086 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18087 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18088 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18089 return resultobj;
18090 fail:
18091 return NULL;
18092 }
18093
18094
18095 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18096 PyObject *resultobj = NULL;
18097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18098 wxDC *arg2 = 0 ;
18099 wxPoint result;
18100 PyObject * obj0 = 0 ;
18101 PyObject * obj1 = 0 ;
18102 char *kwnames[] = {
18103 (char *) "self",(char *) "dc", NULL
18104 };
18105
18106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18111 if (SWIG_arg_fail(2)) SWIG_fail;
18112 if (arg2 == NULL) {
18113 SWIG_null_ref("wxDC");
18114 }
18115 if (SWIG_arg_fail(2)) SWIG_fail;
18116 }
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 {
18125 wxPoint * resultptr;
18126 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18127 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18128 }
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj = NULL;
18137 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18138 int result;
18139 PyObject * obj0 = 0 ;
18140 char *kwnames[] = {
18141 (char *) "self", NULL
18142 };
18143
18144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18146 if (SWIG_arg_fail(1)) SWIG_fail;
18147 {
18148 PyThreadState* __tstate = wxPyBeginAllowThreads();
18149 result = (int)((wxMouseEvent const *)arg1)->GetX();
18150
18151 wxPyEndAllowThreads(__tstate);
18152 if (PyErr_Occurred()) SWIG_fail;
18153 }
18154 {
18155 resultobj = SWIG_From_int(static_cast<int >(result));
18156 }
18157 return resultobj;
18158 fail:
18159 return NULL;
18160 }
18161
18162
18163 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18164 PyObject *resultobj = NULL;
18165 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18166 int result;
18167 PyObject * obj0 = 0 ;
18168 char *kwnames[] = {
18169 (char *) "self", NULL
18170 };
18171
18172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18174 if (SWIG_arg_fail(1)) SWIG_fail;
18175 {
18176 PyThreadState* __tstate = wxPyBeginAllowThreads();
18177 result = (int)((wxMouseEvent const *)arg1)->GetY();
18178
18179 wxPyEndAllowThreads(__tstate);
18180 if (PyErr_Occurred()) SWIG_fail;
18181 }
18182 {
18183 resultobj = SWIG_From_int(static_cast<int >(result));
18184 }
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18192 PyObject *resultobj = NULL;
18193 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18194 int result;
18195 PyObject * obj0 = 0 ;
18196 char *kwnames[] = {
18197 (char *) "self", NULL
18198 };
18199
18200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18202 if (SWIG_arg_fail(1)) SWIG_fail;
18203 {
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18206
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 {
18211 resultobj = SWIG_From_int(static_cast<int >(result));
18212 }
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18220 PyObject *resultobj = NULL;
18221 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18222 int result;
18223 PyObject * obj0 = 0 ;
18224 char *kwnames[] = {
18225 (char *) "self", NULL
18226 };
18227
18228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18230 if (SWIG_arg_fail(1)) SWIG_fail;
18231 {
18232 PyThreadState* __tstate = wxPyBeginAllowThreads();
18233 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18234
18235 wxPyEndAllowThreads(__tstate);
18236 if (PyErr_Occurred()) SWIG_fail;
18237 }
18238 {
18239 resultobj = SWIG_From_int(static_cast<int >(result));
18240 }
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj = NULL;
18249 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18250 int result;
18251 PyObject * obj0 = 0 ;
18252 char *kwnames[] = {
18253 (char *) "self", NULL
18254 };
18255
18256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18258 if (SWIG_arg_fail(1)) SWIG_fail;
18259 {
18260 PyThreadState* __tstate = wxPyBeginAllowThreads();
18261 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18262
18263 wxPyEndAllowThreads(__tstate);
18264 if (PyErr_Occurred()) SWIG_fail;
18265 }
18266 {
18267 resultobj = SWIG_From_int(static_cast<int >(result));
18268 }
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18276 PyObject *resultobj = NULL;
18277 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18278 bool result;
18279 PyObject * obj0 = 0 ;
18280 char *kwnames[] = {
18281 (char *) "self", NULL
18282 };
18283
18284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18286 if (SWIG_arg_fail(1)) SWIG_fail;
18287 {
18288 PyThreadState* __tstate = wxPyBeginAllowThreads();
18289 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18290
18291 wxPyEndAllowThreads(__tstate);
18292 if (PyErr_Occurred()) SWIG_fail;
18293 }
18294 {
18295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18296 }
18297 return resultobj;
18298 fail:
18299 return NULL;
18300 }
18301
18302
18303 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18304 PyObject *resultobj = NULL;
18305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18306 int arg2 ;
18307 PyObject * obj0 = 0 ;
18308 PyObject * obj1 = 0 ;
18309 char *kwnames[] = {
18310 (char *) "self",(char *) "m_x", NULL
18311 };
18312
18313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18315 if (SWIG_arg_fail(1)) SWIG_fail;
18316 {
18317 arg2 = static_cast<int >(SWIG_As_int(obj1));
18318 if (SWIG_arg_fail(2)) SWIG_fail;
18319 }
18320 if (arg1) (arg1)->m_x = arg2;
18321
18322 Py_INCREF(Py_None); resultobj = Py_None;
18323 return resultobj;
18324 fail:
18325 return NULL;
18326 }
18327
18328
18329 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18330 PyObject *resultobj = NULL;
18331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18332 int result;
18333 PyObject * obj0 = 0 ;
18334 char *kwnames[] = {
18335 (char *) "self", NULL
18336 };
18337
18338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18340 if (SWIG_arg_fail(1)) SWIG_fail;
18341 result = (int) ((arg1)->m_x);
18342
18343 {
18344 resultobj = SWIG_From_int(static_cast<int >(result));
18345 }
18346 return resultobj;
18347 fail:
18348 return NULL;
18349 }
18350
18351
18352 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18353 PyObject *resultobj = NULL;
18354 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18355 int arg2 ;
18356 PyObject * obj0 = 0 ;
18357 PyObject * obj1 = 0 ;
18358 char *kwnames[] = {
18359 (char *) "self",(char *) "m_y", NULL
18360 };
18361
18362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18364 if (SWIG_arg_fail(1)) SWIG_fail;
18365 {
18366 arg2 = static_cast<int >(SWIG_As_int(obj1));
18367 if (SWIG_arg_fail(2)) SWIG_fail;
18368 }
18369 if (arg1) (arg1)->m_y = arg2;
18370
18371 Py_INCREF(Py_None); resultobj = Py_None;
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18379 PyObject *resultobj = NULL;
18380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18381 int result;
18382 PyObject * obj0 = 0 ;
18383 char *kwnames[] = {
18384 (char *) "self", NULL
18385 };
18386
18387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18389 if (SWIG_arg_fail(1)) SWIG_fail;
18390 result = (int) ((arg1)->m_y);
18391
18392 {
18393 resultobj = SWIG_From_int(static_cast<int >(result));
18394 }
18395 return resultobj;
18396 fail:
18397 return NULL;
18398 }
18399
18400
18401 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18402 PyObject *resultobj = NULL;
18403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18404 bool arg2 ;
18405 PyObject * obj0 = 0 ;
18406 PyObject * obj1 = 0 ;
18407 char *kwnames[] = {
18408 (char *) "self",(char *) "m_leftDown", NULL
18409 };
18410
18411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18413 if (SWIG_arg_fail(1)) SWIG_fail;
18414 {
18415 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18416 if (SWIG_arg_fail(2)) SWIG_fail;
18417 }
18418 if (arg1) (arg1)->m_leftDown = arg2;
18419
18420 Py_INCREF(Py_None); resultobj = Py_None;
18421 return resultobj;
18422 fail:
18423 return NULL;
18424 }
18425
18426
18427 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18428 PyObject *resultobj = NULL;
18429 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18430 bool result;
18431 PyObject * obj0 = 0 ;
18432 char *kwnames[] = {
18433 (char *) "self", NULL
18434 };
18435
18436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18438 if (SWIG_arg_fail(1)) SWIG_fail;
18439 result = (bool) ((arg1)->m_leftDown);
18440
18441 {
18442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18443 }
18444 return resultobj;
18445 fail:
18446 return NULL;
18447 }
18448
18449
18450 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18451 PyObject *resultobj = NULL;
18452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18453 bool arg2 ;
18454 PyObject * obj0 = 0 ;
18455 PyObject * obj1 = 0 ;
18456 char *kwnames[] = {
18457 (char *) "self",(char *) "m_middleDown", NULL
18458 };
18459
18460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18462 if (SWIG_arg_fail(1)) SWIG_fail;
18463 {
18464 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18465 if (SWIG_arg_fail(2)) SWIG_fail;
18466 }
18467 if (arg1) (arg1)->m_middleDown = arg2;
18468
18469 Py_INCREF(Py_None); resultobj = Py_None;
18470 return resultobj;
18471 fail:
18472 return NULL;
18473 }
18474
18475
18476 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18477 PyObject *resultobj = NULL;
18478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18479 bool result;
18480 PyObject * obj0 = 0 ;
18481 char *kwnames[] = {
18482 (char *) "self", NULL
18483 };
18484
18485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18487 if (SWIG_arg_fail(1)) SWIG_fail;
18488 result = (bool) ((arg1)->m_middleDown);
18489
18490 {
18491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18492 }
18493 return resultobj;
18494 fail:
18495 return NULL;
18496 }
18497
18498
18499 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18500 PyObject *resultobj = NULL;
18501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18502 bool arg2 ;
18503 PyObject * obj0 = 0 ;
18504 PyObject * obj1 = 0 ;
18505 char *kwnames[] = {
18506 (char *) "self",(char *) "m_rightDown", NULL
18507 };
18508
18509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18511 if (SWIG_arg_fail(1)) SWIG_fail;
18512 {
18513 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18514 if (SWIG_arg_fail(2)) SWIG_fail;
18515 }
18516 if (arg1) (arg1)->m_rightDown = arg2;
18517
18518 Py_INCREF(Py_None); resultobj = Py_None;
18519 return resultobj;
18520 fail:
18521 return NULL;
18522 }
18523
18524
18525 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj = NULL;
18527 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18528 bool result;
18529 PyObject * obj0 = 0 ;
18530 char *kwnames[] = {
18531 (char *) "self", NULL
18532 };
18533
18534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18536 if (SWIG_arg_fail(1)) SWIG_fail;
18537 result = (bool) ((arg1)->m_rightDown);
18538
18539 {
18540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18541 }
18542 return resultobj;
18543 fail:
18544 return NULL;
18545 }
18546
18547
18548 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18549 PyObject *resultobj = NULL;
18550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18551 bool arg2 ;
18552 PyObject * obj0 = 0 ;
18553 PyObject * obj1 = 0 ;
18554 char *kwnames[] = {
18555 (char *) "self",(char *) "m_controlDown", NULL
18556 };
18557
18558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18560 if (SWIG_arg_fail(1)) SWIG_fail;
18561 {
18562 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18563 if (SWIG_arg_fail(2)) SWIG_fail;
18564 }
18565 if (arg1) (arg1)->m_controlDown = arg2;
18566
18567 Py_INCREF(Py_None); resultobj = Py_None;
18568 return resultobj;
18569 fail:
18570 return NULL;
18571 }
18572
18573
18574 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18575 PyObject *resultobj = NULL;
18576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18577 bool result;
18578 PyObject * obj0 = 0 ;
18579 char *kwnames[] = {
18580 (char *) "self", NULL
18581 };
18582
18583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18585 if (SWIG_arg_fail(1)) SWIG_fail;
18586 result = (bool) ((arg1)->m_controlDown);
18587
18588 {
18589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18590 }
18591 return resultobj;
18592 fail:
18593 return NULL;
18594 }
18595
18596
18597 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18598 PyObject *resultobj = NULL;
18599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18600 bool arg2 ;
18601 PyObject * obj0 = 0 ;
18602 PyObject * obj1 = 0 ;
18603 char *kwnames[] = {
18604 (char *) "self",(char *) "m_shiftDown", NULL
18605 };
18606
18607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18609 if (SWIG_arg_fail(1)) SWIG_fail;
18610 {
18611 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18612 if (SWIG_arg_fail(2)) SWIG_fail;
18613 }
18614 if (arg1) (arg1)->m_shiftDown = arg2;
18615
18616 Py_INCREF(Py_None); resultobj = Py_None;
18617 return resultobj;
18618 fail:
18619 return NULL;
18620 }
18621
18622
18623 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18624 PyObject *resultobj = NULL;
18625 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18626 bool result;
18627 PyObject * obj0 = 0 ;
18628 char *kwnames[] = {
18629 (char *) "self", NULL
18630 };
18631
18632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18634 if (SWIG_arg_fail(1)) SWIG_fail;
18635 result = (bool) ((arg1)->m_shiftDown);
18636
18637 {
18638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18639 }
18640 return resultobj;
18641 fail:
18642 return NULL;
18643 }
18644
18645
18646 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18647 PyObject *resultobj = NULL;
18648 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18649 bool arg2 ;
18650 PyObject * obj0 = 0 ;
18651 PyObject * obj1 = 0 ;
18652 char *kwnames[] = {
18653 (char *) "self",(char *) "m_altDown", NULL
18654 };
18655
18656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18658 if (SWIG_arg_fail(1)) SWIG_fail;
18659 {
18660 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18661 if (SWIG_arg_fail(2)) SWIG_fail;
18662 }
18663 if (arg1) (arg1)->m_altDown = arg2;
18664
18665 Py_INCREF(Py_None); resultobj = Py_None;
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj = NULL;
18674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18675 bool result;
18676 PyObject * obj0 = 0 ;
18677 char *kwnames[] = {
18678 (char *) "self", NULL
18679 };
18680
18681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18683 if (SWIG_arg_fail(1)) SWIG_fail;
18684 result = (bool) ((arg1)->m_altDown);
18685
18686 {
18687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18688 }
18689 return resultobj;
18690 fail:
18691 return NULL;
18692 }
18693
18694
18695 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj = NULL;
18697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18698 bool arg2 ;
18699 PyObject * obj0 = 0 ;
18700 PyObject * obj1 = 0 ;
18701 char *kwnames[] = {
18702 (char *) "self",(char *) "m_metaDown", NULL
18703 };
18704
18705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18707 if (SWIG_arg_fail(1)) SWIG_fail;
18708 {
18709 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18710 if (SWIG_arg_fail(2)) SWIG_fail;
18711 }
18712 if (arg1) (arg1)->m_metaDown = arg2;
18713
18714 Py_INCREF(Py_None); resultobj = Py_None;
18715 return resultobj;
18716 fail:
18717 return NULL;
18718 }
18719
18720
18721 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18722 PyObject *resultobj = NULL;
18723 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18724 bool result;
18725 PyObject * obj0 = 0 ;
18726 char *kwnames[] = {
18727 (char *) "self", NULL
18728 };
18729
18730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18732 if (SWIG_arg_fail(1)) SWIG_fail;
18733 result = (bool) ((arg1)->m_metaDown);
18734
18735 {
18736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18737 }
18738 return resultobj;
18739 fail:
18740 return NULL;
18741 }
18742
18743
18744 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18745 PyObject *resultobj = NULL;
18746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18747 int arg2 ;
18748 PyObject * obj0 = 0 ;
18749 PyObject * obj1 = 0 ;
18750 char *kwnames[] = {
18751 (char *) "self",(char *) "m_wheelRotation", NULL
18752 };
18753
18754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18756 if (SWIG_arg_fail(1)) SWIG_fail;
18757 {
18758 arg2 = static_cast<int >(SWIG_As_int(obj1));
18759 if (SWIG_arg_fail(2)) SWIG_fail;
18760 }
18761 if (arg1) (arg1)->m_wheelRotation = arg2;
18762
18763 Py_INCREF(Py_None); resultobj = Py_None;
18764 return resultobj;
18765 fail:
18766 return NULL;
18767 }
18768
18769
18770 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18771 PyObject *resultobj = NULL;
18772 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18773 int result;
18774 PyObject * obj0 = 0 ;
18775 char *kwnames[] = {
18776 (char *) "self", NULL
18777 };
18778
18779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18781 if (SWIG_arg_fail(1)) SWIG_fail;
18782 result = (int) ((arg1)->m_wheelRotation);
18783
18784 {
18785 resultobj = SWIG_From_int(static_cast<int >(result));
18786 }
18787 return resultobj;
18788 fail:
18789 return NULL;
18790 }
18791
18792
18793 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18794 PyObject *resultobj = NULL;
18795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18796 int arg2 ;
18797 PyObject * obj0 = 0 ;
18798 PyObject * obj1 = 0 ;
18799 char *kwnames[] = {
18800 (char *) "self",(char *) "m_wheelDelta", NULL
18801 };
18802
18803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18805 if (SWIG_arg_fail(1)) SWIG_fail;
18806 {
18807 arg2 = static_cast<int >(SWIG_As_int(obj1));
18808 if (SWIG_arg_fail(2)) SWIG_fail;
18809 }
18810 if (arg1) (arg1)->m_wheelDelta = arg2;
18811
18812 Py_INCREF(Py_None); resultobj = Py_None;
18813 return resultobj;
18814 fail:
18815 return NULL;
18816 }
18817
18818
18819 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18820 PyObject *resultobj = NULL;
18821 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18822 int result;
18823 PyObject * obj0 = 0 ;
18824 char *kwnames[] = {
18825 (char *) "self", NULL
18826 };
18827
18828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18830 if (SWIG_arg_fail(1)) SWIG_fail;
18831 result = (int) ((arg1)->m_wheelDelta);
18832
18833 {
18834 resultobj = SWIG_From_int(static_cast<int >(result));
18835 }
18836 return resultobj;
18837 fail:
18838 return NULL;
18839 }
18840
18841
18842 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18843 PyObject *resultobj = NULL;
18844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18845 int arg2 ;
18846 PyObject * obj0 = 0 ;
18847 PyObject * obj1 = 0 ;
18848 char *kwnames[] = {
18849 (char *) "self",(char *) "m_linesPerAction", NULL
18850 };
18851
18852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18854 if (SWIG_arg_fail(1)) SWIG_fail;
18855 {
18856 arg2 = static_cast<int >(SWIG_As_int(obj1));
18857 if (SWIG_arg_fail(2)) SWIG_fail;
18858 }
18859 if (arg1) (arg1)->m_linesPerAction = arg2;
18860
18861 Py_INCREF(Py_None); resultobj = Py_None;
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18869 PyObject *resultobj = NULL;
18870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18871 int result;
18872 PyObject * obj0 = 0 ;
18873 char *kwnames[] = {
18874 (char *) "self", NULL
18875 };
18876
18877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18879 if (SWIG_arg_fail(1)) SWIG_fail;
18880 result = (int) ((arg1)->m_linesPerAction);
18881
18882 {
18883 resultobj = SWIG_From_int(static_cast<int >(result));
18884 }
18885 return resultobj;
18886 fail:
18887 return NULL;
18888 }
18889
18890
18891 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18892 PyObject *obj;
18893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18894 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18895 Py_INCREF(obj);
18896 return Py_BuildValue((char *)"");
18897 }
18898 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj = NULL;
18900 int arg1 = (int) 0 ;
18901 int arg2 = (int) 0 ;
18902 wxSetCursorEvent *result;
18903 PyObject * obj0 = 0 ;
18904 PyObject * obj1 = 0 ;
18905 char *kwnames[] = {
18906 (char *) "x",(char *) "y", NULL
18907 };
18908
18909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18910 if (obj0) {
18911 {
18912 arg1 = static_cast<int >(SWIG_As_int(obj0));
18913 if (SWIG_arg_fail(1)) SWIG_fail;
18914 }
18915 }
18916 if (obj1) {
18917 {
18918 arg2 = static_cast<int >(SWIG_As_int(obj1));
18919 if (SWIG_arg_fail(2)) SWIG_fail;
18920 }
18921 }
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18925
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj = NULL;
18938 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18939 int result;
18940 PyObject * obj0 = 0 ;
18941 char *kwnames[] = {
18942 (char *) "self", NULL
18943 };
18944
18945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18947 if (SWIG_arg_fail(1)) SWIG_fail;
18948 {
18949 PyThreadState* __tstate = wxPyBeginAllowThreads();
18950 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18951
18952 wxPyEndAllowThreads(__tstate);
18953 if (PyErr_Occurred()) SWIG_fail;
18954 }
18955 {
18956 resultobj = SWIG_From_int(static_cast<int >(result));
18957 }
18958 return resultobj;
18959 fail:
18960 return NULL;
18961 }
18962
18963
18964 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18965 PyObject *resultobj = NULL;
18966 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18967 int result;
18968 PyObject * obj0 = 0 ;
18969 char *kwnames[] = {
18970 (char *) "self", NULL
18971 };
18972
18973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18975 if (SWIG_arg_fail(1)) SWIG_fail;
18976 {
18977 PyThreadState* __tstate = wxPyBeginAllowThreads();
18978 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18979
18980 wxPyEndAllowThreads(__tstate);
18981 if (PyErr_Occurred()) SWIG_fail;
18982 }
18983 {
18984 resultobj = SWIG_From_int(static_cast<int >(result));
18985 }
18986 return resultobj;
18987 fail:
18988 return NULL;
18989 }
18990
18991
18992 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18993 PyObject *resultobj = NULL;
18994 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18995 wxCursor *arg2 = 0 ;
18996 PyObject * obj0 = 0 ;
18997 PyObject * obj1 = 0 ;
18998 char *kwnames[] = {
18999 (char *) "self",(char *) "cursor", NULL
19000 };
19001
19002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
19003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19004 if (SWIG_arg_fail(1)) SWIG_fail;
19005 {
19006 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
19007 if (SWIG_arg_fail(2)) SWIG_fail;
19008 if (arg2 == NULL) {
19009 SWIG_null_ref("wxCursor");
19010 }
19011 if (SWIG_arg_fail(2)) SWIG_fail;
19012 }
19013 {
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 (arg1)->SetCursor((wxCursor const &)*arg2);
19016
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 Py_INCREF(Py_None); resultobj = Py_None;
19021 return resultobj;
19022 fail:
19023 return NULL;
19024 }
19025
19026
19027 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19028 PyObject *resultobj = NULL;
19029 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19030 wxCursor *result;
19031 PyObject * obj0 = 0 ;
19032 char *kwnames[] = {
19033 (char *) "self", NULL
19034 };
19035
19036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19038 if (SWIG_arg_fail(1)) SWIG_fail;
19039 {
19040 PyThreadState* __tstate = wxPyBeginAllowThreads();
19041 {
19042 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19043 result = (wxCursor *) &_result_ref;
19044 }
19045
19046 wxPyEndAllowThreads(__tstate);
19047 if (PyErr_Occurred()) SWIG_fail;
19048 }
19049 {
19050 wxCursor* resultptr = new wxCursor(*result);
19051 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19052 }
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj = NULL;
19061 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19062 bool result;
19063 PyObject * obj0 = 0 ;
19064 char *kwnames[] = {
19065 (char *) "self", NULL
19066 };
19067
19068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",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 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19074
19075 wxPyEndAllowThreads(__tstate);
19076 if (PyErr_Occurred()) SWIG_fail;
19077 }
19078 {
19079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19080 }
19081 return resultobj;
19082 fail:
19083 return NULL;
19084 }
19085
19086
19087 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19088 PyObject *obj;
19089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19090 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19091 Py_INCREF(obj);
19092 return Py_BuildValue((char *)"");
19093 }
19094 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19095 PyObject *resultobj = NULL;
19096 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19097 wxKeyEvent *result;
19098 PyObject * obj0 = 0 ;
19099 char *kwnames[] = {
19100 (char *) "eventType", NULL
19101 };
19102
19103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19104 if (obj0) {
19105 {
19106 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19107 if (SWIG_arg_fail(1)) SWIG_fail;
19108 }
19109 }
19110 {
19111 PyThreadState* __tstate = wxPyBeginAllowThreads();
19112 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19113
19114 wxPyEndAllowThreads(__tstate);
19115 if (PyErr_Occurred()) SWIG_fail;
19116 }
19117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19118 return resultobj;
19119 fail:
19120 return NULL;
19121 }
19122
19123
19124 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19125 PyObject *resultobj = NULL;
19126 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19127 bool result;
19128 PyObject * obj0 = 0 ;
19129 char *kwnames[] = {
19130 (char *) "self", NULL
19131 };
19132
19133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19135 if (SWIG_arg_fail(1)) SWIG_fail;
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19139
19140 wxPyEndAllowThreads(__tstate);
19141 if (PyErr_Occurred()) SWIG_fail;
19142 }
19143 {
19144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19145 }
19146 return resultobj;
19147 fail:
19148 return NULL;
19149 }
19150
19151
19152 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19153 PyObject *resultobj = NULL;
19154 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19155 bool result;
19156 PyObject * obj0 = 0 ;
19157 char *kwnames[] = {
19158 (char *) "self", NULL
19159 };
19160
19161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19163 if (SWIG_arg_fail(1)) SWIG_fail;
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19167
19168 wxPyEndAllowThreads(__tstate);
19169 if (PyErr_Occurred()) SWIG_fail;
19170 }
19171 {
19172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19173 }
19174 return resultobj;
19175 fail:
19176 return NULL;
19177 }
19178
19179
19180 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19181 PyObject *resultobj = NULL;
19182 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19183 bool result;
19184 PyObject * obj0 = 0 ;
19185 char *kwnames[] = {
19186 (char *) "self", NULL
19187 };
19188
19189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19191 if (SWIG_arg_fail(1)) SWIG_fail;
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19195
19196 wxPyEndAllowThreads(__tstate);
19197 if (PyErr_Occurred()) SWIG_fail;
19198 }
19199 {
19200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19201 }
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj = NULL;
19210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19211 bool result;
19212 PyObject * obj0 = 0 ;
19213 char *kwnames[] = {
19214 (char *) "self", NULL
19215 };
19216
19217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19219 if (SWIG_arg_fail(1)) SWIG_fail;
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19223
19224 wxPyEndAllowThreads(__tstate);
19225 if (PyErr_Occurred()) SWIG_fail;
19226 }
19227 {
19228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19229 }
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19237 PyObject *resultobj = NULL;
19238 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19239 bool result;
19240 PyObject * obj0 = 0 ;
19241 char *kwnames[] = {
19242 (char *) "self", NULL
19243 };
19244
19245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19247 if (SWIG_arg_fail(1)) SWIG_fail;
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19251
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19257 }
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj = NULL;
19266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19267 bool result;
19268 PyObject * obj0 = 0 ;
19269 char *kwnames[] = {
19270 (char *) "self", NULL
19271 };
19272
19273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19275 if (SWIG_arg_fail(1)) SWIG_fail;
19276 {
19277 PyThreadState* __tstate = wxPyBeginAllowThreads();
19278 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19279
19280 wxPyEndAllowThreads(__tstate);
19281 if (PyErr_Occurred()) SWIG_fail;
19282 }
19283 {
19284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19285 }
19286 return resultobj;
19287 fail:
19288 return NULL;
19289 }
19290
19291
19292 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19293 PyObject *resultobj = NULL;
19294 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19295 int result;
19296 PyObject * obj0 = 0 ;
19297 char *kwnames[] = {
19298 (char *) "self", NULL
19299 };
19300
19301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19303 if (SWIG_arg_fail(1)) SWIG_fail;
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19307
19308 wxPyEndAllowThreads(__tstate);
19309 if (PyErr_Occurred()) SWIG_fail;
19310 }
19311 {
19312 resultobj = SWIG_From_int(static_cast<int >(result));
19313 }
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19321 PyObject *resultobj = NULL;
19322 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19323 int result;
19324 PyObject * obj0 = 0 ;
19325 char *kwnames[] = {
19326 (char *) "self", NULL
19327 };
19328
19329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19331 if (SWIG_arg_fail(1)) SWIG_fail;
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19335
19336 wxPyEndAllowThreads(__tstate);
19337 if (PyErr_Occurred()) SWIG_fail;
19338 }
19339 {
19340 resultobj = SWIG_From_int(static_cast<int >(result));
19341 }
19342 return resultobj;
19343 fail:
19344 return NULL;
19345 }
19346
19347
19348 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19349 PyObject *resultobj = NULL;
19350 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19351 unsigned int result;
19352 PyObject * obj0 = 0 ;
19353 char *kwnames[] = {
19354 (char *) "self", NULL
19355 };
19356
19357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19359 if (SWIG_arg_fail(1)) SWIG_fail;
19360 {
19361 PyThreadState* __tstate = wxPyBeginAllowThreads();
19362 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19363
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 {
19368 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19369 }
19370 return resultobj;
19371 fail:
19372 return NULL;
19373 }
19374
19375
19376 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19377 PyObject *resultobj = NULL;
19378 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19379 unsigned int result;
19380 PyObject * obj0 = 0 ;
19381 char *kwnames[] = {
19382 (char *) "self", NULL
19383 };
19384
19385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19387 if (SWIG_arg_fail(1)) SWIG_fail;
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19391
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 {
19396 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19397 }
19398 return resultobj;
19399 fail:
19400 return NULL;
19401 }
19402
19403
19404 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19405 PyObject *resultobj = NULL;
19406 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19407 wxPoint result;
19408 PyObject * obj0 = 0 ;
19409 char *kwnames[] = {
19410 (char *) "self", NULL
19411 };
19412
19413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19415 if (SWIG_arg_fail(1)) SWIG_fail;
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 result = (arg1)->GetPosition();
19419
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 {
19424 wxPoint * resultptr;
19425 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19427 }
19428 return resultobj;
19429 fail:
19430 return NULL;
19431 }
19432
19433
19434 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19435 PyObject *resultobj = NULL;
19436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19437 long *arg2 = (long *) 0 ;
19438 long *arg3 = (long *) 0 ;
19439 long temp2 ;
19440 int res2 = 0 ;
19441 long temp3 ;
19442 int res3 = 0 ;
19443 PyObject * obj0 = 0 ;
19444 char *kwnames[] = {
19445 (char *) "self", NULL
19446 };
19447
19448 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19449 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19452 if (SWIG_arg_fail(1)) SWIG_fail;
19453 {
19454 PyThreadState* __tstate = wxPyBeginAllowThreads();
19455 (arg1)->GetPosition(arg2,arg3);
19456
19457 wxPyEndAllowThreads(__tstate);
19458 if (PyErr_Occurred()) SWIG_fail;
19459 }
19460 Py_INCREF(Py_None); resultobj = Py_None;
19461 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19462 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19463 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19464 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19465 return resultobj;
19466 fail:
19467 return NULL;
19468 }
19469
19470
19471 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19472 PyObject *resultobj = NULL;
19473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19474 int result;
19475 PyObject * obj0 = 0 ;
19476 char *kwnames[] = {
19477 (char *) "self", NULL
19478 };
19479
19480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19482 if (SWIG_arg_fail(1)) SWIG_fail;
19483 {
19484 PyThreadState* __tstate = wxPyBeginAllowThreads();
19485 result = (int)((wxKeyEvent const *)arg1)->GetX();
19486
19487 wxPyEndAllowThreads(__tstate);
19488 if (PyErr_Occurred()) SWIG_fail;
19489 }
19490 {
19491 resultobj = SWIG_From_int(static_cast<int >(result));
19492 }
19493 return resultobj;
19494 fail:
19495 return NULL;
19496 }
19497
19498
19499 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19500 PyObject *resultobj = NULL;
19501 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19502 int result;
19503 PyObject * obj0 = 0 ;
19504 char *kwnames[] = {
19505 (char *) "self", NULL
19506 };
19507
19508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19510 if (SWIG_arg_fail(1)) SWIG_fail;
19511 {
19512 PyThreadState* __tstate = wxPyBeginAllowThreads();
19513 result = (int)((wxKeyEvent const *)arg1)->GetY();
19514
19515 wxPyEndAllowThreads(__tstate);
19516 if (PyErr_Occurred()) SWIG_fail;
19517 }
19518 {
19519 resultobj = SWIG_From_int(static_cast<int >(result));
19520 }
19521 return resultobj;
19522 fail:
19523 return NULL;
19524 }
19525
19526
19527 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj = NULL;
19529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19530 int arg2 ;
19531 PyObject * obj0 = 0 ;
19532 PyObject * obj1 = 0 ;
19533 char *kwnames[] = {
19534 (char *) "self",(char *) "m_x", NULL
19535 };
19536
19537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19539 if (SWIG_arg_fail(1)) SWIG_fail;
19540 {
19541 arg2 = static_cast<int >(SWIG_As_int(obj1));
19542 if (SWIG_arg_fail(2)) SWIG_fail;
19543 }
19544 if (arg1) (arg1)->m_x = arg2;
19545
19546 Py_INCREF(Py_None); resultobj = Py_None;
19547 return resultobj;
19548 fail:
19549 return NULL;
19550 }
19551
19552
19553 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19554 PyObject *resultobj = NULL;
19555 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19556 int result;
19557 PyObject * obj0 = 0 ;
19558 char *kwnames[] = {
19559 (char *) "self", NULL
19560 };
19561
19562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19564 if (SWIG_arg_fail(1)) SWIG_fail;
19565 result = (int) ((arg1)->m_x);
19566
19567 {
19568 resultobj = SWIG_From_int(static_cast<int >(result));
19569 }
19570 return resultobj;
19571 fail:
19572 return NULL;
19573 }
19574
19575
19576 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19577 PyObject *resultobj = NULL;
19578 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19579 int arg2 ;
19580 PyObject * obj0 = 0 ;
19581 PyObject * obj1 = 0 ;
19582 char *kwnames[] = {
19583 (char *) "self",(char *) "m_y", NULL
19584 };
19585
19586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19588 if (SWIG_arg_fail(1)) SWIG_fail;
19589 {
19590 arg2 = static_cast<int >(SWIG_As_int(obj1));
19591 if (SWIG_arg_fail(2)) SWIG_fail;
19592 }
19593 if (arg1) (arg1)->m_y = arg2;
19594
19595 Py_INCREF(Py_None); resultobj = Py_None;
19596 return resultobj;
19597 fail:
19598 return NULL;
19599 }
19600
19601
19602 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19603 PyObject *resultobj = NULL;
19604 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19605 int result;
19606 PyObject * obj0 = 0 ;
19607 char *kwnames[] = {
19608 (char *) "self", NULL
19609 };
19610
19611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19613 if (SWIG_arg_fail(1)) SWIG_fail;
19614 result = (int) ((arg1)->m_y);
19615
19616 {
19617 resultobj = SWIG_From_int(static_cast<int >(result));
19618 }
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj = NULL;
19627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19628 long arg2 ;
19629 PyObject * obj0 = 0 ;
19630 PyObject * obj1 = 0 ;
19631 char *kwnames[] = {
19632 (char *) "self",(char *) "m_keyCode", NULL
19633 };
19634
19635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19637 if (SWIG_arg_fail(1)) SWIG_fail;
19638 {
19639 arg2 = static_cast<long >(SWIG_As_long(obj1));
19640 if (SWIG_arg_fail(2)) SWIG_fail;
19641 }
19642 if (arg1) (arg1)->m_keyCode = arg2;
19643
19644 Py_INCREF(Py_None); resultobj = Py_None;
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj = NULL;
19653 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19654 long result;
19655 PyObject * obj0 = 0 ;
19656 char *kwnames[] = {
19657 (char *) "self", NULL
19658 };
19659
19660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19662 if (SWIG_arg_fail(1)) SWIG_fail;
19663 result = (long) ((arg1)->m_keyCode);
19664
19665 {
19666 resultobj = SWIG_From_long(static_cast<long >(result));
19667 }
19668 return resultobj;
19669 fail:
19670 return NULL;
19671 }
19672
19673
19674 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19675 PyObject *resultobj = NULL;
19676 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19677 bool arg2 ;
19678 PyObject * obj0 = 0 ;
19679 PyObject * obj1 = 0 ;
19680 char *kwnames[] = {
19681 (char *) "self",(char *) "m_controlDown", NULL
19682 };
19683
19684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19686 if (SWIG_arg_fail(1)) SWIG_fail;
19687 {
19688 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19689 if (SWIG_arg_fail(2)) SWIG_fail;
19690 }
19691 if (arg1) (arg1)->m_controlDown = arg2;
19692
19693 Py_INCREF(Py_None); resultobj = Py_None;
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19701 PyObject *resultobj = NULL;
19702 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19703 bool result;
19704 PyObject * obj0 = 0 ;
19705 char *kwnames[] = {
19706 (char *) "self", NULL
19707 };
19708
19709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19711 if (SWIG_arg_fail(1)) SWIG_fail;
19712 result = (bool) ((arg1)->m_controlDown);
19713
19714 {
19715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19716 }
19717 return resultobj;
19718 fail:
19719 return NULL;
19720 }
19721
19722
19723 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19724 PyObject *resultobj = NULL;
19725 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19726 bool arg2 ;
19727 PyObject * obj0 = 0 ;
19728 PyObject * obj1 = 0 ;
19729 char *kwnames[] = {
19730 (char *) "self",(char *) "m_shiftDown", NULL
19731 };
19732
19733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19735 if (SWIG_arg_fail(1)) SWIG_fail;
19736 {
19737 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19738 if (SWIG_arg_fail(2)) SWIG_fail;
19739 }
19740 if (arg1) (arg1)->m_shiftDown = arg2;
19741
19742 Py_INCREF(Py_None); resultobj = Py_None;
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19750 PyObject *resultobj = NULL;
19751 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19752 bool result;
19753 PyObject * obj0 = 0 ;
19754 char *kwnames[] = {
19755 (char *) "self", NULL
19756 };
19757
19758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19760 if (SWIG_arg_fail(1)) SWIG_fail;
19761 result = (bool) ((arg1)->m_shiftDown);
19762
19763 {
19764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19765 }
19766 return resultobj;
19767 fail:
19768 return NULL;
19769 }
19770
19771
19772 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19773 PyObject *resultobj = NULL;
19774 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19775 bool arg2 ;
19776 PyObject * obj0 = 0 ;
19777 PyObject * obj1 = 0 ;
19778 char *kwnames[] = {
19779 (char *) "self",(char *) "m_altDown", NULL
19780 };
19781
19782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19784 if (SWIG_arg_fail(1)) SWIG_fail;
19785 {
19786 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19787 if (SWIG_arg_fail(2)) SWIG_fail;
19788 }
19789 if (arg1) (arg1)->m_altDown = arg2;
19790
19791 Py_INCREF(Py_None); resultobj = Py_None;
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19799 PyObject *resultobj = NULL;
19800 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19801 bool result;
19802 PyObject * obj0 = 0 ;
19803 char *kwnames[] = {
19804 (char *) "self", NULL
19805 };
19806
19807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19809 if (SWIG_arg_fail(1)) SWIG_fail;
19810 result = (bool) ((arg1)->m_altDown);
19811
19812 {
19813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19814 }
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj = NULL;
19823 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19824 bool arg2 ;
19825 PyObject * obj0 = 0 ;
19826 PyObject * obj1 = 0 ;
19827 char *kwnames[] = {
19828 (char *) "self",(char *) "m_metaDown", NULL
19829 };
19830
19831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19833 if (SWIG_arg_fail(1)) SWIG_fail;
19834 {
19835 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19836 if (SWIG_arg_fail(2)) SWIG_fail;
19837 }
19838 if (arg1) (arg1)->m_metaDown = arg2;
19839
19840 Py_INCREF(Py_None); resultobj = Py_None;
19841 return resultobj;
19842 fail:
19843 return NULL;
19844 }
19845
19846
19847 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19848 PyObject *resultobj = NULL;
19849 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19850 bool result;
19851 PyObject * obj0 = 0 ;
19852 char *kwnames[] = {
19853 (char *) "self", NULL
19854 };
19855
19856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19858 if (SWIG_arg_fail(1)) SWIG_fail;
19859 result = (bool) ((arg1)->m_metaDown);
19860
19861 {
19862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19863 }
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19871 PyObject *resultobj = NULL;
19872 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19873 bool arg2 ;
19874 PyObject * obj0 = 0 ;
19875 PyObject * obj1 = 0 ;
19876 char *kwnames[] = {
19877 (char *) "self",(char *) "m_scanCode", NULL
19878 };
19879
19880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19882 if (SWIG_arg_fail(1)) SWIG_fail;
19883 {
19884 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19885 if (SWIG_arg_fail(2)) SWIG_fail;
19886 }
19887 if (arg1) (arg1)->m_scanCode = arg2;
19888
19889 Py_INCREF(Py_None); resultobj = Py_None;
19890 return resultobj;
19891 fail:
19892 return NULL;
19893 }
19894
19895
19896 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19897 PyObject *resultobj = NULL;
19898 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19899 bool result;
19900 PyObject * obj0 = 0 ;
19901 char *kwnames[] = {
19902 (char *) "self", NULL
19903 };
19904
19905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19907 if (SWIG_arg_fail(1)) SWIG_fail;
19908 result = (bool) ((arg1)->m_scanCode);
19909
19910 {
19911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19912 }
19913 return resultobj;
19914 fail:
19915 return NULL;
19916 }
19917
19918
19919 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19920 PyObject *resultobj = NULL;
19921 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19922 unsigned int arg2 ;
19923 PyObject * obj0 = 0 ;
19924 PyObject * obj1 = 0 ;
19925 char *kwnames[] = {
19926 (char *) "self",(char *) "m_rawCode", NULL
19927 };
19928
19929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19931 if (SWIG_arg_fail(1)) SWIG_fail;
19932 {
19933 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19934 if (SWIG_arg_fail(2)) SWIG_fail;
19935 }
19936 if (arg1) (arg1)->m_rawCode = arg2;
19937
19938 Py_INCREF(Py_None); resultobj = Py_None;
19939 return resultobj;
19940 fail:
19941 return NULL;
19942 }
19943
19944
19945 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19946 PyObject *resultobj = NULL;
19947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19948 unsigned int result;
19949 PyObject * obj0 = 0 ;
19950 char *kwnames[] = {
19951 (char *) "self", NULL
19952 };
19953
19954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19956 if (SWIG_arg_fail(1)) SWIG_fail;
19957 result = (unsigned int) ((arg1)->m_rawCode);
19958
19959 {
19960 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19961 }
19962 return resultobj;
19963 fail:
19964 return NULL;
19965 }
19966
19967
19968 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19969 PyObject *resultobj = NULL;
19970 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19971 unsigned int arg2 ;
19972 PyObject * obj0 = 0 ;
19973 PyObject * obj1 = 0 ;
19974 char *kwnames[] = {
19975 (char *) "self",(char *) "m_rawFlags", NULL
19976 };
19977
19978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19980 if (SWIG_arg_fail(1)) SWIG_fail;
19981 {
19982 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19983 if (SWIG_arg_fail(2)) SWIG_fail;
19984 }
19985 if (arg1) (arg1)->m_rawFlags = arg2;
19986
19987 Py_INCREF(Py_None); resultobj = Py_None;
19988 return resultobj;
19989 fail:
19990 return NULL;
19991 }
19992
19993
19994 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19995 PyObject *resultobj = NULL;
19996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19997 unsigned int result;
19998 PyObject * obj0 = 0 ;
19999 char *kwnames[] = {
20000 (char *) "self", NULL
20001 };
20002
20003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
20004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20005 if (SWIG_arg_fail(1)) SWIG_fail;
20006 result = (unsigned int) ((arg1)->m_rawFlags);
20007
20008 {
20009 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20010 }
20011 return resultobj;
20012 fail:
20013 return NULL;
20014 }
20015
20016
20017 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
20018 PyObject *obj;
20019 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20020 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
20021 Py_INCREF(obj);
20022 return Py_BuildValue((char *)"");
20023 }
20024 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20025 PyObject *resultobj = NULL;
20026 wxSize const &arg1_defvalue = wxDefaultSize ;
20027 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20028 int arg2 = (int) 0 ;
20029 wxSizeEvent *result;
20030 wxSize temp1 ;
20031 PyObject * obj0 = 0 ;
20032 PyObject * obj1 = 0 ;
20033 char *kwnames[] = {
20034 (char *) "sz",(char *) "winid", NULL
20035 };
20036
20037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20038 if (obj0) {
20039 {
20040 arg1 = &temp1;
20041 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20042 }
20043 }
20044 if (obj1) {
20045 {
20046 arg2 = static_cast<int >(SWIG_As_int(obj1));
20047 if (SWIG_arg_fail(2)) SWIG_fail;
20048 }
20049 }
20050 {
20051 PyThreadState* __tstate = wxPyBeginAllowThreads();
20052 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20053
20054 wxPyEndAllowThreads(__tstate);
20055 if (PyErr_Occurred()) SWIG_fail;
20056 }
20057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20058 return resultobj;
20059 fail:
20060 return NULL;
20061 }
20062
20063
20064 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20065 PyObject *resultobj = NULL;
20066 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20067 wxSize result;
20068 PyObject * obj0 = 0 ;
20069 char *kwnames[] = {
20070 (char *) "self", NULL
20071 };
20072
20073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20075 if (SWIG_arg_fail(1)) SWIG_fail;
20076 {
20077 PyThreadState* __tstate = wxPyBeginAllowThreads();
20078 result = ((wxSizeEvent const *)arg1)->GetSize();
20079
20080 wxPyEndAllowThreads(__tstate);
20081 if (PyErr_Occurred()) SWIG_fail;
20082 }
20083 {
20084 wxSize * resultptr;
20085 resultptr = new wxSize(static_cast<wxSize & >(result));
20086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20087 }
20088 return resultobj;
20089 fail:
20090 return NULL;
20091 }
20092
20093
20094 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20095 PyObject *resultobj = NULL;
20096 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20097 wxRect result;
20098 PyObject * obj0 = 0 ;
20099 char *kwnames[] = {
20100 (char *) "self", NULL
20101 };
20102
20103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20105 if (SWIG_arg_fail(1)) SWIG_fail;
20106 {
20107 PyThreadState* __tstate = wxPyBeginAllowThreads();
20108 result = ((wxSizeEvent const *)arg1)->GetRect();
20109
20110 wxPyEndAllowThreads(__tstate);
20111 if (PyErr_Occurred()) SWIG_fail;
20112 }
20113 {
20114 wxRect * resultptr;
20115 resultptr = new wxRect(static_cast<wxRect & >(result));
20116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20117 }
20118 return resultobj;
20119 fail:
20120 return NULL;
20121 }
20122
20123
20124 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20125 PyObject *resultobj = NULL;
20126 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20127 wxRect arg2 ;
20128 PyObject * obj0 = 0 ;
20129 PyObject * obj1 = 0 ;
20130 char *kwnames[] = {
20131 (char *) "self",(char *) "rect", NULL
20132 };
20133
20134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20136 if (SWIG_arg_fail(1)) SWIG_fail;
20137 {
20138 wxRect * argp;
20139 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20140 if (SWIG_arg_fail(2)) SWIG_fail;
20141 if (argp == NULL) {
20142 SWIG_null_ref("wxRect");
20143 }
20144 if (SWIG_arg_fail(2)) SWIG_fail;
20145 arg2 = *argp;
20146 }
20147 {
20148 PyThreadState* __tstate = wxPyBeginAllowThreads();
20149 (arg1)->SetRect(arg2);
20150
20151 wxPyEndAllowThreads(__tstate);
20152 if (PyErr_Occurred()) SWIG_fail;
20153 }
20154 Py_INCREF(Py_None); resultobj = Py_None;
20155 return resultobj;
20156 fail:
20157 return NULL;
20158 }
20159
20160
20161 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20162 PyObject *resultobj = NULL;
20163 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20164 wxSize arg2 ;
20165 PyObject * obj0 = 0 ;
20166 PyObject * obj1 = 0 ;
20167 char *kwnames[] = {
20168 (char *) "self",(char *) "size", NULL
20169 };
20170
20171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20173 if (SWIG_arg_fail(1)) SWIG_fail;
20174 {
20175 wxSize * argp;
20176 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20177 if (SWIG_arg_fail(2)) SWIG_fail;
20178 if (argp == NULL) {
20179 SWIG_null_ref("wxSize");
20180 }
20181 if (SWIG_arg_fail(2)) SWIG_fail;
20182 arg2 = *argp;
20183 }
20184 {
20185 PyThreadState* __tstate = wxPyBeginAllowThreads();
20186 wxSizeEvent_SetSize(arg1,arg2);
20187
20188 wxPyEndAllowThreads(__tstate);
20189 if (PyErr_Occurred()) SWIG_fail;
20190 }
20191 Py_INCREF(Py_None); resultobj = Py_None;
20192 return resultobj;
20193 fail:
20194 return NULL;
20195 }
20196
20197
20198 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20199 PyObject *resultobj = NULL;
20200 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20201 wxSize *arg2 = (wxSize *) 0 ;
20202 PyObject * obj0 = 0 ;
20203 PyObject * obj1 = 0 ;
20204 char *kwnames[] = {
20205 (char *) "self",(char *) "m_size", NULL
20206 };
20207
20208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20210 if (SWIG_arg_fail(1)) SWIG_fail;
20211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20212 if (SWIG_arg_fail(2)) SWIG_fail;
20213 if (arg1) (arg1)->m_size = *arg2;
20214
20215 Py_INCREF(Py_None); resultobj = Py_None;
20216 return resultobj;
20217 fail:
20218 return NULL;
20219 }
20220
20221
20222 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20223 PyObject *resultobj = NULL;
20224 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20225 wxSize *result;
20226 PyObject * obj0 = 0 ;
20227 char *kwnames[] = {
20228 (char *) "self", NULL
20229 };
20230
20231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) 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 result = (wxSize *)& ((arg1)->m_size);
20235
20236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20237 return resultobj;
20238 fail:
20239 return NULL;
20240 }
20241
20242
20243 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20244 PyObject *resultobj = NULL;
20245 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20246 wxRect *arg2 = (wxRect *) 0 ;
20247 PyObject * obj0 = 0 ;
20248 PyObject * obj1 = 0 ;
20249 char *kwnames[] = {
20250 (char *) "self",(char *) "m_rect", NULL
20251 };
20252
20253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20255 if (SWIG_arg_fail(1)) SWIG_fail;
20256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20257 if (SWIG_arg_fail(2)) SWIG_fail;
20258 if (arg1) (arg1)->m_rect = *arg2;
20259
20260 Py_INCREF(Py_None); resultobj = Py_None;
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20268 PyObject *resultobj = NULL;
20269 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20270 wxRect *result;
20271 PyObject * obj0 = 0 ;
20272 char *kwnames[] = {
20273 (char *) "self", NULL
20274 };
20275
20276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20278 if (SWIG_arg_fail(1)) SWIG_fail;
20279 result = (wxRect *)& ((arg1)->m_rect);
20280
20281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20282 return resultobj;
20283 fail:
20284 return NULL;
20285 }
20286
20287
20288 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20289 PyObject *obj;
20290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20291 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20292 Py_INCREF(obj);
20293 return Py_BuildValue((char *)"");
20294 }
20295 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20296 PyObject *resultobj = NULL;
20297 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20298 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20299 int arg2 = (int) 0 ;
20300 wxMoveEvent *result;
20301 wxPoint temp1 ;
20302 PyObject * obj0 = 0 ;
20303 PyObject * obj1 = 0 ;
20304 char *kwnames[] = {
20305 (char *) "pos",(char *) "winid", NULL
20306 };
20307
20308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20309 if (obj0) {
20310 {
20311 arg1 = &temp1;
20312 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20313 }
20314 }
20315 if (obj1) {
20316 {
20317 arg2 = static_cast<int >(SWIG_As_int(obj1));
20318 if (SWIG_arg_fail(2)) SWIG_fail;
20319 }
20320 }
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20324
20325 wxPyEndAllowThreads(__tstate);
20326 if (PyErr_Occurred()) SWIG_fail;
20327 }
20328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20329 return resultobj;
20330 fail:
20331 return NULL;
20332 }
20333
20334
20335 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20336 PyObject *resultobj = NULL;
20337 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20338 wxPoint result;
20339 PyObject * obj0 = 0 ;
20340 char *kwnames[] = {
20341 (char *) "self", NULL
20342 };
20343
20344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20346 if (SWIG_arg_fail(1)) SWIG_fail;
20347 {
20348 PyThreadState* __tstate = wxPyBeginAllowThreads();
20349 result = ((wxMoveEvent const *)arg1)->GetPosition();
20350
20351 wxPyEndAllowThreads(__tstate);
20352 if (PyErr_Occurred()) SWIG_fail;
20353 }
20354 {
20355 wxPoint * resultptr;
20356 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20358 }
20359 return resultobj;
20360 fail:
20361 return NULL;
20362 }
20363
20364
20365 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20366 PyObject *resultobj = NULL;
20367 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20368 wxRect result;
20369 PyObject * obj0 = 0 ;
20370 char *kwnames[] = {
20371 (char *) "self", NULL
20372 };
20373
20374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20376 if (SWIG_arg_fail(1)) SWIG_fail;
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = ((wxMoveEvent const *)arg1)->GetRect();
20380
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 {
20385 wxRect * resultptr;
20386 resultptr = new wxRect(static_cast<wxRect & >(result));
20387 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20388 }
20389 return resultobj;
20390 fail:
20391 return NULL;
20392 }
20393
20394
20395 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20396 PyObject *resultobj = NULL;
20397 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20398 wxRect *arg2 = 0 ;
20399 wxRect temp2 ;
20400 PyObject * obj0 = 0 ;
20401 PyObject * obj1 = 0 ;
20402 char *kwnames[] = {
20403 (char *) "self",(char *) "rect", NULL
20404 };
20405
20406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20408 if (SWIG_arg_fail(1)) SWIG_fail;
20409 {
20410 arg2 = &temp2;
20411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20412 }
20413 {
20414 PyThreadState* __tstate = wxPyBeginAllowThreads();
20415 (arg1)->SetRect((wxRect const &)*arg2);
20416
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 Py_INCREF(Py_None); resultobj = Py_None;
20421 return resultobj;
20422 fail:
20423 return NULL;
20424 }
20425
20426
20427 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20428 PyObject *resultobj = NULL;
20429 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20430 wxPoint *arg2 = 0 ;
20431 wxPoint temp2 ;
20432 PyObject * obj0 = 0 ;
20433 PyObject * obj1 = 0 ;
20434 char *kwnames[] = {
20435 (char *) "self",(char *) "pos", NULL
20436 };
20437
20438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20440 if (SWIG_arg_fail(1)) SWIG_fail;
20441 {
20442 arg2 = &temp2;
20443 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20444 }
20445 {
20446 PyThreadState* __tstate = wxPyBeginAllowThreads();
20447 (arg1)->SetPosition((wxPoint const &)*arg2);
20448
20449 wxPyEndAllowThreads(__tstate);
20450 if (PyErr_Occurred()) SWIG_fail;
20451 }
20452 Py_INCREF(Py_None); resultobj = Py_None;
20453 return resultobj;
20454 fail:
20455 return NULL;
20456 }
20457
20458
20459 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20460 PyObject *obj;
20461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20462 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20463 Py_INCREF(obj);
20464 return Py_BuildValue((char *)"");
20465 }
20466 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20467 PyObject *resultobj = NULL;
20468 int arg1 = (int) 0 ;
20469 wxPaintEvent *result;
20470 PyObject * obj0 = 0 ;
20471 char *kwnames[] = {
20472 (char *) "Id", NULL
20473 };
20474
20475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20476 if (obj0) {
20477 {
20478 arg1 = static_cast<int >(SWIG_As_int(obj0));
20479 if (SWIG_arg_fail(1)) SWIG_fail;
20480 }
20481 }
20482 {
20483 PyThreadState* __tstate = wxPyBeginAllowThreads();
20484 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20485
20486 wxPyEndAllowThreads(__tstate);
20487 if (PyErr_Occurred()) SWIG_fail;
20488 }
20489 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20490 return resultobj;
20491 fail:
20492 return NULL;
20493 }
20494
20495
20496 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20497 PyObject *obj;
20498 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20499 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20500 Py_INCREF(obj);
20501 return Py_BuildValue((char *)"");
20502 }
20503 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20504 PyObject *resultobj = NULL;
20505 int arg1 = (int) 0 ;
20506 wxNcPaintEvent *result;
20507 PyObject * obj0 = 0 ;
20508 char *kwnames[] = {
20509 (char *) "winid", NULL
20510 };
20511
20512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20513 if (obj0) {
20514 {
20515 arg1 = static_cast<int >(SWIG_As_int(obj0));
20516 if (SWIG_arg_fail(1)) SWIG_fail;
20517 }
20518 }
20519 {
20520 PyThreadState* __tstate = wxPyBeginAllowThreads();
20521 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20522
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20527 return resultobj;
20528 fail:
20529 return NULL;
20530 }
20531
20532
20533 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20534 PyObject *obj;
20535 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20536 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20537 Py_INCREF(obj);
20538 return Py_BuildValue((char *)"");
20539 }
20540 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20541 PyObject *resultobj = NULL;
20542 int arg1 = (int) 0 ;
20543 wxDC *arg2 = (wxDC *) NULL ;
20544 wxEraseEvent *result;
20545 PyObject * obj0 = 0 ;
20546 PyObject * obj1 = 0 ;
20547 char *kwnames[] = {
20548 (char *) "Id",(char *) "dc", NULL
20549 };
20550
20551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20552 if (obj0) {
20553 {
20554 arg1 = static_cast<int >(SWIG_As_int(obj0));
20555 if (SWIG_arg_fail(1)) SWIG_fail;
20556 }
20557 }
20558 if (obj1) {
20559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20560 if (SWIG_arg_fail(2)) SWIG_fail;
20561 }
20562 {
20563 PyThreadState* __tstate = wxPyBeginAllowThreads();
20564 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20565
20566 wxPyEndAllowThreads(__tstate);
20567 if (PyErr_Occurred()) SWIG_fail;
20568 }
20569 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20570 return resultobj;
20571 fail:
20572 return NULL;
20573 }
20574
20575
20576 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20577 PyObject *resultobj = NULL;
20578 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20579 wxDC *result;
20580 PyObject * obj0 = 0 ;
20581 char *kwnames[] = {
20582 (char *) "self", NULL
20583 };
20584
20585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20587 if (SWIG_arg_fail(1)) SWIG_fail;
20588 {
20589 PyThreadState* __tstate = wxPyBeginAllowThreads();
20590 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20591
20592 wxPyEndAllowThreads(__tstate);
20593 if (PyErr_Occurred()) SWIG_fail;
20594 }
20595 {
20596 resultobj = wxPyMake_wxObject(result, (bool)0);
20597 }
20598 return resultobj;
20599 fail:
20600 return NULL;
20601 }
20602
20603
20604 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20605 PyObject *obj;
20606 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20607 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20608 Py_INCREF(obj);
20609 return Py_BuildValue((char *)"");
20610 }
20611 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20612 PyObject *resultobj = NULL;
20613 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20614 int arg2 = (int) 0 ;
20615 wxFocusEvent *result;
20616 PyObject * obj0 = 0 ;
20617 PyObject * obj1 = 0 ;
20618 char *kwnames[] = {
20619 (char *) "type",(char *) "winid", NULL
20620 };
20621
20622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20623 if (obj0) {
20624 {
20625 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20626 if (SWIG_arg_fail(1)) SWIG_fail;
20627 }
20628 }
20629 if (obj1) {
20630 {
20631 arg2 = static_cast<int >(SWIG_As_int(obj1));
20632 if (SWIG_arg_fail(2)) SWIG_fail;
20633 }
20634 }
20635 {
20636 PyThreadState* __tstate = wxPyBeginAllowThreads();
20637 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20638
20639 wxPyEndAllowThreads(__tstate);
20640 if (PyErr_Occurred()) SWIG_fail;
20641 }
20642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20643 return resultobj;
20644 fail:
20645 return NULL;
20646 }
20647
20648
20649 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20650 PyObject *resultobj = NULL;
20651 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20652 wxWindow *result;
20653 PyObject * obj0 = 0 ;
20654 char *kwnames[] = {
20655 (char *) "self", NULL
20656 };
20657
20658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20660 if (SWIG_arg_fail(1)) SWIG_fail;
20661 {
20662 PyThreadState* __tstate = wxPyBeginAllowThreads();
20663 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20664
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 {
20669 resultobj = wxPyMake_wxObject(result, (bool)0);
20670 }
20671 return resultobj;
20672 fail:
20673 return NULL;
20674 }
20675
20676
20677 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20678 PyObject *resultobj = NULL;
20679 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20680 wxWindow *arg2 = (wxWindow *) 0 ;
20681 PyObject * obj0 = 0 ;
20682 PyObject * obj1 = 0 ;
20683 char *kwnames[] = {
20684 (char *) "self",(char *) "win", NULL
20685 };
20686
20687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20689 if (SWIG_arg_fail(1)) SWIG_fail;
20690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20691 if (SWIG_arg_fail(2)) SWIG_fail;
20692 {
20693 PyThreadState* __tstate = wxPyBeginAllowThreads();
20694 (arg1)->SetWindow(arg2);
20695
20696 wxPyEndAllowThreads(__tstate);
20697 if (PyErr_Occurred()) SWIG_fail;
20698 }
20699 Py_INCREF(Py_None); resultobj = Py_None;
20700 return resultobj;
20701 fail:
20702 return NULL;
20703 }
20704
20705
20706 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20707 PyObject *obj;
20708 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20709 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20710 Py_INCREF(obj);
20711 return Py_BuildValue((char *)"");
20712 }
20713 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20714 PyObject *resultobj = NULL;
20715 wxWindow *arg1 = (wxWindow *) NULL ;
20716 wxChildFocusEvent *result;
20717 PyObject * obj0 = 0 ;
20718 char *kwnames[] = {
20719 (char *) "win", NULL
20720 };
20721
20722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20723 if (obj0) {
20724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20725 if (SWIG_arg_fail(1)) SWIG_fail;
20726 }
20727 {
20728 PyThreadState* __tstate = wxPyBeginAllowThreads();
20729 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20730
20731 wxPyEndAllowThreads(__tstate);
20732 if (PyErr_Occurred()) SWIG_fail;
20733 }
20734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20735 return resultobj;
20736 fail:
20737 return NULL;
20738 }
20739
20740
20741 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20742 PyObject *resultobj = NULL;
20743 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20744 wxWindow *result;
20745 PyObject * obj0 = 0 ;
20746 char *kwnames[] = {
20747 (char *) "self", NULL
20748 };
20749
20750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20752 if (SWIG_arg_fail(1)) SWIG_fail;
20753 {
20754 PyThreadState* __tstate = wxPyBeginAllowThreads();
20755 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20756
20757 wxPyEndAllowThreads(__tstate);
20758 if (PyErr_Occurred()) SWIG_fail;
20759 }
20760 {
20761 resultobj = wxPyMake_wxObject(result, (bool)0);
20762 }
20763 return resultobj;
20764 fail:
20765 return NULL;
20766 }
20767
20768
20769 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20770 PyObject *obj;
20771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20772 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20773 Py_INCREF(obj);
20774 return Py_BuildValue((char *)"");
20775 }
20776 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20777 PyObject *resultobj = NULL;
20778 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20779 bool arg2 = (bool) true ;
20780 int arg3 = (int) 0 ;
20781 wxActivateEvent *result;
20782 PyObject * obj0 = 0 ;
20783 PyObject * obj1 = 0 ;
20784 PyObject * obj2 = 0 ;
20785 char *kwnames[] = {
20786 (char *) "type",(char *) "active",(char *) "Id", NULL
20787 };
20788
20789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20790 if (obj0) {
20791 {
20792 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20793 if (SWIG_arg_fail(1)) SWIG_fail;
20794 }
20795 }
20796 if (obj1) {
20797 {
20798 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20799 if (SWIG_arg_fail(2)) SWIG_fail;
20800 }
20801 }
20802 if (obj2) {
20803 {
20804 arg3 = static_cast<int >(SWIG_As_int(obj2));
20805 if (SWIG_arg_fail(3)) SWIG_fail;
20806 }
20807 }
20808 {
20809 PyThreadState* __tstate = wxPyBeginAllowThreads();
20810 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20811
20812 wxPyEndAllowThreads(__tstate);
20813 if (PyErr_Occurred()) SWIG_fail;
20814 }
20815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20816 return resultobj;
20817 fail:
20818 return NULL;
20819 }
20820
20821
20822 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20823 PyObject *resultobj = NULL;
20824 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20825 bool result;
20826 PyObject * obj0 = 0 ;
20827 char *kwnames[] = {
20828 (char *) "self", NULL
20829 };
20830
20831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20833 if (SWIG_arg_fail(1)) SWIG_fail;
20834 {
20835 PyThreadState* __tstate = wxPyBeginAllowThreads();
20836 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20837
20838 wxPyEndAllowThreads(__tstate);
20839 if (PyErr_Occurred()) SWIG_fail;
20840 }
20841 {
20842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20843 }
20844 return resultobj;
20845 fail:
20846 return NULL;
20847 }
20848
20849
20850 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20851 PyObject *obj;
20852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20853 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20854 Py_INCREF(obj);
20855 return Py_BuildValue((char *)"");
20856 }
20857 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20858 PyObject *resultobj = NULL;
20859 int arg1 = (int) 0 ;
20860 wxInitDialogEvent *result;
20861 PyObject * obj0 = 0 ;
20862 char *kwnames[] = {
20863 (char *) "Id", NULL
20864 };
20865
20866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20867 if (obj0) {
20868 {
20869 arg1 = static_cast<int >(SWIG_As_int(obj0));
20870 if (SWIG_arg_fail(1)) SWIG_fail;
20871 }
20872 }
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20876
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20881 return resultobj;
20882 fail:
20883 return NULL;
20884 }
20885
20886
20887 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20888 PyObject *obj;
20889 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20890 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20891 Py_INCREF(obj);
20892 return Py_BuildValue((char *)"");
20893 }
20894 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20895 PyObject *resultobj = NULL;
20896 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20897 int arg2 = (int) 0 ;
20898 wxMenu *arg3 = (wxMenu *) NULL ;
20899 wxMenuEvent *result;
20900 PyObject * obj0 = 0 ;
20901 PyObject * obj1 = 0 ;
20902 PyObject * obj2 = 0 ;
20903 char *kwnames[] = {
20904 (char *) "type",(char *) "winid",(char *) "menu", NULL
20905 };
20906
20907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20908 if (obj0) {
20909 {
20910 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20911 if (SWIG_arg_fail(1)) SWIG_fail;
20912 }
20913 }
20914 if (obj1) {
20915 {
20916 arg2 = static_cast<int >(SWIG_As_int(obj1));
20917 if (SWIG_arg_fail(2)) SWIG_fail;
20918 }
20919 }
20920 if (obj2) {
20921 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20922 if (SWIG_arg_fail(3)) SWIG_fail;
20923 }
20924 {
20925 PyThreadState* __tstate = wxPyBeginAllowThreads();
20926 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20927
20928 wxPyEndAllowThreads(__tstate);
20929 if (PyErr_Occurred()) SWIG_fail;
20930 }
20931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20932 return resultobj;
20933 fail:
20934 return NULL;
20935 }
20936
20937
20938 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20939 PyObject *resultobj = NULL;
20940 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20941 int result;
20942 PyObject * obj0 = 0 ;
20943 char *kwnames[] = {
20944 (char *) "self", NULL
20945 };
20946
20947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20949 if (SWIG_arg_fail(1)) SWIG_fail;
20950 {
20951 PyThreadState* __tstate = wxPyBeginAllowThreads();
20952 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20953
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 {
20958 resultobj = SWIG_From_int(static_cast<int >(result));
20959 }
20960 return resultobj;
20961 fail:
20962 return NULL;
20963 }
20964
20965
20966 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20967 PyObject *resultobj = NULL;
20968 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20969 bool result;
20970 PyObject * obj0 = 0 ;
20971 char *kwnames[] = {
20972 (char *) "self", NULL
20973 };
20974
20975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20977 if (SWIG_arg_fail(1)) SWIG_fail;
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20981
20982 wxPyEndAllowThreads(__tstate);
20983 if (PyErr_Occurred()) SWIG_fail;
20984 }
20985 {
20986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20987 }
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj = NULL;
20996 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20997 wxMenu *result;
20998 PyObject * obj0 = 0 ;
20999 char *kwnames[] = {
21000 (char *) "self", NULL
21001 };
21002
21003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
21004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21005 if (SWIG_arg_fail(1)) SWIG_fail;
21006 {
21007 PyThreadState* __tstate = wxPyBeginAllowThreads();
21008 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
21009
21010 wxPyEndAllowThreads(__tstate);
21011 if (PyErr_Occurred()) SWIG_fail;
21012 }
21013 {
21014 resultobj = wxPyMake_wxObject(result, (bool)0);
21015 }
21016 return resultobj;
21017 fail:
21018 return NULL;
21019 }
21020
21021
21022 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
21023 PyObject *obj;
21024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21025 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21026 Py_INCREF(obj);
21027 return Py_BuildValue((char *)"");
21028 }
21029 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj = NULL;
21031 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21032 int arg2 = (int) 0 ;
21033 wxCloseEvent *result;
21034 PyObject * obj0 = 0 ;
21035 PyObject * obj1 = 0 ;
21036 char *kwnames[] = {
21037 (char *) "type",(char *) "winid", NULL
21038 };
21039
21040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21041 if (obj0) {
21042 {
21043 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21044 if (SWIG_arg_fail(1)) SWIG_fail;
21045 }
21046 }
21047 if (obj1) {
21048 {
21049 arg2 = static_cast<int >(SWIG_As_int(obj1));
21050 if (SWIG_arg_fail(2)) SWIG_fail;
21051 }
21052 }
21053 {
21054 PyThreadState* __tstate = wxPyBeginAllowThreads();
21055 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21056
21057 wxPyEndAllowThreads(__tstate);
21058 if (PyErr_Occurred()) SWIG_fail;
21059 }
21060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21061 return resultobj;
21062 fail:
21063 return NULL;
21064 }
21065
21066
21067 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21068 PyObject *resultobj = NULL;
21069 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21070 bool arg2 ;
21071 PyObject * obj0 = 0 ;
21072 PyObject * obj1 = 0 ;
21073 char *kwnames[] = {
21074 (char *) "self",(char *) "logOff", NULL
21075 };
21076
21077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21079 if (SWIG_arg_fail(1)) SWIG_fail;
21080 {
21081 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21082 if (SWIG_arg_fail(2)) SWIG_fail;
21083 }
21084 {
21085 PyThreadState* __tstate = wxPyBeginAllowThreads();
21086 (arg1)->SetLoggingOff(arg2);
21087
21088 wxPyEndAllowThreads(__tstate);
21089 if (PyErr_Occurred()) SWIG_fail;
21090 }
21091 Py_INCREF(Py_None); resultobj = Py_None;
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21099 PyObject *resultobj = NULL;
21100 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21101 bool result;
21102 PyObject * obj0 = 0 ;
21103 char *kwnames[] = {
21104 (char *) "self", NULL
21105 };
21106
21107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21109 if (SWIG_arg_fail(1)) SWIG_fail;
21110 {
21111 PyThreadState* __tstate = wxPyBeginAllowThreads();
21112 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21113
21114 wxPyEndAllowThreads(__tstate);
21115 if (PyErr_Occurred()) SWIG_fail;
21116 }
21117 {
21118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21119 }
21120 return resultobj;
21121 fail:
21122 return NULL;
21123 }
21124
21125
21126 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21127 PyObject *resultobj = NULL;
21128 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21129 bool arg2 = (bool) true ;
21130 PyObject * obj0 = 0 ;
21131 PyObject * obj1 = 0 ;
21132 char *kwnames[] = {
21133 (char *) "self",(char *) "veto", NULL
21134 };
21135
21136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21138 if (SWIG_arg_fail(1)) SWIG_fail;
21139 if (obj1) {
21140 {
21141 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21142 if (SWIG_arg_fail(2)) SWIG_fail;
21143 }
21144 }
21145 {
21146 PyThreadState* __tstate = wxPyBeginAllowThreads();
21147 (arg1)->Veto(arg2);
21148
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 Py_INCREF(Py_None); resultobj = Py_None;
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21160 PyObject *resultobj = NULL;
21161 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21162 bool result;
21163 PyObject * obj0 = 0 ;
21164 char *kwnames[] = {
21165 (char *) "self", NULL
21166 };
21167
21168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21170 if (SWIG_arg_fail(1)) SWIG_fail;
21171 {
21172 PyThreadState* __tstate = wxPyBeginAllowThreads();
21173 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21174
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 {
21179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21180 }
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21188 PyObject *resultobj = NULL;
21189 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21190 bool arg2 ;
21191 PyObject * obj0 = 0 ;
21192 PyObject * obj1 = 0 ;
21193 char *kwnames[] = {
21194 (char *) "self",(char *) "canVeto", NULL
21195 };
21196
21197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21199 if (SWIG_arg_fail(1)) SWIG_fail;
21200 {
21201 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21202 if (SWIG_arg_fail(2)) SWIG_fail;
21203 }
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 (arg1)->SetCanVeto(arg2);
21207
21208 wxPyEndAllowThreads(__tstate);
21209 if (PyErr_Occurred()) SWIG_fail;
21210 }
21211 Py_INCREF(Py_None); resultobj = Py_None;
21212 return resultobj;
21213 fail:
21214 return NULL;
21215 }
21216
21217
21218 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21219 PyObject *resultobj = NULL;
21220 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21221 bool result;
21222 PyObject * obj0 = 0 ;
21223 char *kwnames[] = {
21224 (char *) "self", NULL
21225 };
21226
21227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21229 if (SWIG_arg_fail(1)) SWIG_fail;
21230 {
21231 PyThreadState* __tstate = wxPyBeginAllowThreads();
21232 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21233
21234 wxPyEndAllowThreads(__tstate);
21235 if (PyErr_Occurred()) SWIG_fail;
21236 }
21237 {
21238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21239 }
21240 return resultobj;
21241 fail:
21242 return NULL;
21243 }
21244
21245
21246 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21247 PyObject *obj;
21248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21249 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21250 Py_INCREF(obj);
21251 return Py_BuildValue((char *)"");
21252 }
21253 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21254 PyObject *resultobj = NULL;
21255 int arg1 = (int) 0 ;
21256 bool arg2 = (bool) false ;
21257 wxShowEvent *result;
21258 PyObject * obj0 = 0 ;
21259 PyObject * obj1 = 0 ;
21260 char *kwnames[] = {
21261 (char *) "winid",(char *) "show", NULL
21262 };
21263
21264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21265 if (obj0) {
21266 {
21267 arg1 = static_cast<int >(SWIG_As_int(obj0));
21268 if (SWIG_arg_fail(1)) SWIG_fail;
21269 }
21270 }
21271 if (obj1) {
21272 {
21273 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21274 if (SWIG_arg_fail(2)) SWIG_fail;
21275 }
21276 }
21277 {
21278 PyThreadState* __tstate = wxPyBeginAllowThreads();
21279 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21280
21281 wxPyEndAllowThreads(__tstate);
21282 if (PyErr_Occurred()) SWIG_fail;
21283 }
21284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21285 return resultobj;
21286 fail:
21287 return NULL;
21288 }
21289
21290
21291 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21292 PyObject *resultobj = NULL;
21293 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21294 bool arg2 ;
21295 PyObject * obj0 = 0 ;
21296 PyObject * obj1 = 0 ;
21297 char *kwnames[] = {
21298 (char *) "self",(char *) "show", NULL
21299 };
21300
21301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21303 if (SWIG_arg_fail(1)) SWIG_fail;
21304 {
21305 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21306 if (SWIG_arg_fail(2)) SWIG_fail;
21307 }
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 (arg1)->SetShow(arg2);
21311
21312 wxPyEndAllowThreads(__tstate);
21313 if (PyErr_Occurred()) SWIG_fail;
21314 }
21315 Py_INCREF(Py_None); resultobj = Py_None;
21316 return resultobj;
21317 fail:
21318 return NULL;
21319 }
21320
21321
21322 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21323 PyObject *resultobj = NULL;
21324 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21325 bool result;
21326 PyObject * obj0 = 0 ;
21327 char *kwnames[] = {
21328 (char *) "self", NULL
21329 };
21330
21331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 {
21335 PyThreadState* __tstate = wxPyBeginAllowThreads();
21336 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21337
21338 wxPyEndAllowThreads(__tstate);
21339 if (PyErr_Occurred()) SWIG_fail;
21340 }
21341 {
21342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21343 }
21344 return resultobj;
21345 fail:
21346 return NULL;
21347 }
21348
21349
21350 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21351 PyObject *obj;
21352 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21353 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21354 Py_INCREF(obj);
21355 return Py_BuildValue((char *)"");
21356 }
21357 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21358 PyObject *resultobj = NULL;
21359 int arg1 = (int) 0 ;
21360 bool arg2 = (bool) true ;
21361 wxIconizeEvent *result;
21362 PyObject * obj0 = 0 ;
21363 PyObject * obj1 = 0 ;
21364 char *kwnames[] = {
21365 (char *) "id",(char *) "iconized", NULL
21366 };
21367
21368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21369 if (obj0) {
21370 {
21371 arg1 = static_cast<int >(SWIG_As_int(obj0));
21372 if (SWIG_arg_fail(1)) SWIG_fail;
21373 }
21374 }
21375 if (obj1) {
21376 {
21377 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21378 if (SWIG_arg_fail(2)) SWIG_fail;
21379 }
21380 }
21381 {
21382 PyThreadState* __tstate = wxPyBeginAllowThreads();
21383 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21384
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21389 return resultobj;
21390 fail:
21391 return NULL;
21392 }
21393
21394
21395 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21396 PyObject *resultobj = NULL;
21397 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21398 bool result;
21399 PyObject * obj0 = 0 ;
21400 char *kwnames[] = {
21401 (char *) "self", NULL
21402 };
21403
21404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21406 if (SWIG_arg_fail(1)) SWIG_fail;
21407 {
21408 PyThreadState* __tstate = wxPyBeginAllowThreads();
21409 result = (bool)(arg1)->Iconized();
21410
21411 wxPyEndAllowThreads(__tstate);
21412 if (PyErr_Occurred()) SWIG_fail;
21413 }
21414 {
21415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21416 }
21417 return resultobj;
21418 fail:
21419 return NULL;
21420 }
21421
21422
21423 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21424 PyObject *obj;
21425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21426 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21427 Py_INCREF(obj);
21428 return Py_BuildValue((char *)"");
21429 }
21430 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21431 PyObject *resultobj = NULL;
21432 int arg1 = (int) 0 ;
21433 wxMaximizeEvent *result;
21434 PyObject * obj0 = 0 ;
21435 char *kwnames[] = {
21436 (char *) "id", NULL
21437 };
21438
21439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21440 if (obj0) {
21441 {
21442 arg1 = static_cast<int >(SWIG_As_int(obj0));
21443 if (SWIG_arg_fail(1)) SWIG_fail;
21444 }
21445 }
21446 {
21447 PyThreadState* __tstate = wxPyBeginAllowThreads();
21448 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21449
21450 wxPyEndAllowThreads(__tstate);
21451 if (PyErr_Occurred()) SWIG_fail;
21452 }
21453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21454 return resultobj;
21455 fail:
21456 return NULL;
21457 }
21458
21459
21460 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21461 PyObject *obj;
21462 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21463 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21464 Py_INCREF(obj);
21465 return Py_BuildValue((char *)"");
21466 }
21467 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21468 PyObject *resultobj = NULL;
21469 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21470 wxPoint result;
21471 PyObject * obj0 = 0 ;
21472 char *kwnames[] = {
21473 (char *) "self", NULL
21474 };
21475
21476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21478 if (SWIG_arg_fail(1)) SWIG_fail;
21479 {
21480 PyThreadState* __tstate = wxPyBeginAllowThreads();
21481 result = (arg1)->GetPosition();
21482
21483 wxPyEndAllowThreads(__tstate);
21484 if (PyErr_Occurred()) SWIG_fail;
21485 }
21486 {
21487 wxPoint * resultptr;
21488 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21489 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21490 }
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj = NULL;
21499 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21500 int result;
21501 PyObject * obj0 = 0 ;
21502 char *kwnames[] = {
21503 (char *) "self", NULL
21504 };
21505
21506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21508 if (SWIG_arg_fail(1)) SWIG_fail;
21509 {
21510 PyThreadState* __tstate = wxPyBeginAllowThreads();
21511 result = (int)(arg1)->GetNumberOfFiles();
21512
21513 wxPyEndAllowThreads(__tstate);
21514 if (PyErr_Occurred()) SWIG_fail;
21515 }
21516 {
21517 resultobj = SWIG_From_int(static_cast<int >(result));
21518 }
21519 return resultobj;
21520 fail:
21521 return NULL;
21522 }
21523
21524
21525 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21526 PyObject *resultobj = NULL;
21527 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21528 PyObject *result;
21529 PyObject * obj0 = 0 ;
21530 char *kwnames[] = {
21531 (char *) "self", NULL
21532 };
21533
21534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21536 if (SWIG_arg_fail(1)) SWIG_fail;
21537 {
21538 PyThreadState* __tstate = wxPyBeginAllowThreads();
21539 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21540
21541 wxPyEndAllowThreads(__tstate);
21542 if (PyErr_Occurred()) SWIG_fail;
21543 }
21544 resultobj = result;
21545 return resultobj;
21546 fail:
21547 return NULL;
21548 }
21549
21550
21551 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21552 PyObject *obj;
21553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21554 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21555 Py_INCREF(obj);
21556 return Py_BuildValue((char *)"");
21557 }
21558 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21559 PyObject *resultobj = NULL;
21560 int arg1 = (int) 0 ;
21561 wxUpdateUIEvent *result;
21562 PyObject * obj0 = 0 ;
21563 char *kwnames[] = {
21564 (char *) "commandId", NULL
21565 };
21566
21567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21568 if (obj0) {
21569 {
21570 arg1 = static_cast<int >(SWIG_As_int(obj0));
21571 if (SWIG_arg_fail(1)) SWIG_fail;
21572 }
21573 }
21574 {
21575 PyThreadState* __tstate = wxPyBeginAllowThreads();
21576 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21577
21578 wxPyEndAllowThreads(__tstate);
21579 if (PyErr_Occurred()) SWIG_fail;
21580 }
21581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21589 PyObject *resultobj = NULL;
21590 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21591 bool result;
21592 PyObject * obj0 = 0 ;
21593 char *kwnames[] = {
21594 (char *) "self", NULL
21595 };
21596
21597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21599 if (SWIG_arg_fail(1)) SWIG_fail;
21600 {
21601 PyThreadState* __tstate = wxPyBeginAllowThreads();
21602 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21603
21604 wxPyEndAllowThreads(__tstate);
21605 if (PyErr_Occurred()) SWIG_fail;
21606 }
21607 {
21608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21609 }
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21617 PyObject *resultobj = NULL;
21618 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21619 bool result;
21620 PyObject * obj0 = 0 ;
21621 char *kwnames[] = {
21622 (char *) "self", NULL
21623 };
21624
21625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21627 if (SWIG_arg_fail(1)) SWIG_fail;
21628 {
21629 PyThreadState* __tstate = wxPyBeginAllowThreads();
21630 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21631
21632 wxPyEndAllowThreads(__tstate);
21633 if (PyErr_Occurred()) SWIG_fail;
21634 }
21635 {
21636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21637 }
21638 return resultobj;
21639 fail:
21640 return NULL;
21641 }
21642
21643
21644 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21645 PyObject *resultobj = NULL;
21646 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21647 wxString result;
21648 PyObject * obj0 = 0 ;
21649 char *kwnames[] = {
21650 (char *) "self", NULL
21651 };
21652
21653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21655 if (SWIG_arg_fail(1)) SWIG_fail;
21656 {
21657 PyThreadState* __tstate = wxPyBeginAllowThreads();
21658 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21659
21660 wxPyEndAllowThreads(__tstate);
21661 if (PyErr_Occurred()) SWIG_fail;
21662 }
21663 {
21664 #if wxUSE_UNICODE
21665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21666 #else
21667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21668 #endif
21669 }
21670 return resultobj;
21671 fail:
21672 return NULL;
21673 }
21674
21675
21676 static PyObject *_wrap_UpdateUIEvent_GetSetText(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_GetSetText",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)->GetSetText();
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_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21705 PyObject *resultobj = NULL;
21706 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21707 bool result;
21708 PyObject * obj0 = 0 ;
21709 char *kwnames[] = {
21710 (char *) "self", NULL
21711 };
21712
21713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",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 = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 {
21724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21725 }
21726 return resultobj;
21727 fail:
21728 return NULL;
21729 }
21730
21731
21732 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21733 PyObject *resultobj = NULL;
21734 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21735 bool result;
21736 PyObject * obj0 = 0 ;
21737 char *kwnames[] = {
21738 (char *) "self", NULL
21739 };
21740
21741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21743 if (SWIG_arg_fail(1)) SWIG_fail;
21744 {
21745 PyThreadState* __tstate = wxPyBeginAllowThreads();
21746 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21747
21748 wxPyEndAllowThreads(__tstate);
21749 if (PyErr_Occurred()) SWIG_fail;
21750 }
21751 {
21752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21753 }
21754 return resultobj;
21755 fail:
21756 return NULL;
21757 }
21758
21759
21760 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21761 PyObject *resultobj = NULL;
21762 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21763 bool arg2 ;
21764 PyObject * obj0 = 0 ;
21765 PyObject * obj1 = 0 ;
21766 char *kwnames[] = {
21767 (char *) "self",(char *) "check", NULL
21768 };
21769
21770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21772 if (SWIG_arg_fail(1)) SWIG_fail;
21773 {
21774 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21775 if (SWIG_arg_fail(2)) SWIG_fail;
21776 }
21777 {
21778 PyThreadState* __tstate = wxPyBeginAllowThreads();
21779 (arg1)->Check(arg2);
21780
21781 wxPyEndAllowThreads(__tstate);
21782 if (PyErr_Occurred()) SWIG_fail;
21783 }
21784 Py_INCREF(Py_None); resultobj = Py_None;
21785 return resultobj;
21786 fail:
21787 return NULL;
21788 }
21789
21790
21791 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21792 PyObject *resultobj = NULL;
21793 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21794 bool arg2 ;
21795 PyObject * obj0 = 0 ;
21796 PyObject * obj1 = 0 ;
21797 char *kwnames[] = {
21798 (char *) "self",(char *) "enable", NULL
21799 };
21800
21801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) 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 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21806 if (SWIG_arg_fail(2)) SWIG_fail;
21807 }
21808 {
21809 PyThreadState* __tstate = wxPyBeginAllowThreads();
21810 (arg1)->Enable(arg2);
21811
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 Py_INCREF(Py_None); resultobj = Py_None;
21816 return resultobj;
21817 fail:
21818 return NULL;
21819 }
21820
21821
21822 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj = NULL;
21824 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21825 wxString *arg2 = 0 ;
21826 bool temp2 = false ;
21827 PyObject * obj0 = 0 ;
21828 PyObject * obj1 = 0 ;
21829 char *kwnames[] = {
21830 (char *) "self",(char *) "text", NULL
21831 };
21832
21833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21835 if (SWIG_arg_fail(1)) SWIG_fail;
21836 {
21837 arg2 = wxString_in_helper(obj1);
21838 if (arg2 == NULL) SWIG_fail;
21839 temp2 = true;
21840 }
21841 {
21842 PyThreadState* __tstate = wxPyBeginAllowThreads();
21843 (arg1)->SetText((wxString const &)*arg2);
21844
21845 wxPyEndAllowThreads(__tstate);
21846 if (PyErr_Occurred()) SWIG_fail;
21847 }
21848 Py_INCREF(Py_None); resultobj = Py_None;
21849 {
21850 if (temp2)
21851 delete arg2;
21852 }
21853 return resultobj;
21854 fail:
21855 {
21856 if (temp2)
21857 delete arg2;
21858 }
21859 return NULL;
21860 }
21861
21862
21863 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21864 PyObject *resultobj = NULL;
21865 long arg1 ;
21866 PyObject * obj0 = 0 ;
21867 char *kwnames[] = {
21868 (char *) "updateInterval", NULL
21869 };
21870
21871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21872 {
21873 arg1 = static_cast<long >(SWIG_As_long(obj0));
21874 if (SWIG_arg_fail(1)) SWIG_fail;
21875 }
21876 {
21877 PyThreadState* __tstate = wxPyBeginAllowThreads();
21878 wxUpdateUIEvent::SetUpdateInterval(arg1);
21879
21880 wxPyEndAllowThreads(__tstate);
21881 if (PyErr_Occurred()) SWIG_fail;
21882 }
21883 Py_INCREF(Py_None); resultobj = Py_None;
21884 return resultobj;
21885 fail:
21886 return NULL;
21887 }
21888
21889
21890 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21891 PyObject *resultobj = NULL;
21892 long result;
21893 char *kwnames[] = {
21894 NULL
21895 };
21896
21897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21898 {
21899 PyThreadState* __tstate = wxPyBeginAllowThreads();
21900 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21901
21902 wxPyEndAllowThreads(__tstate);
21903 if (PyErr_Occurred()) SWIG_fail;
21904 }
21905 {
21906 resultobj = SWIG_From_long(static_cast<long >(result));
21907 }
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21915 PyObject *resultobj = NULL;
21916 wxWindow *arg1 = (wxWindow *) 0 ;
21917 bool result;
21918 PyObject * obj0 = 0 ;
21919 char *kwnames[] = {
21920 (char *) "win", NULL
21921 };
21922
21923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21925 if (SWIG_arg_fail(1)) SWIG_fail;
21926 {
21927 PyThreadState* __tstate = wxPyBeginAllowThreads();
21928 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21929
21930 wxPyEndAllowThreads(__tstate);
21931 if (PyErr_Occurred()) SWIG_fail;
21932 }
21933 {
21934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21935 }
21936 return resultobj;
21937 fail:
21938 return NULL;
21939 }
21940
21941
21942 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21943 PyObject *resultobj = NULL;
21944 char *kwnames[] = {
21945 NULL
21946 };
21947
21948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21949 {
21950 PyThreadState* __tstate = wxPyBeginAllowThreads();
21951 wxUpdateUIEvent::ResetUpdateTime();
21952
21953 wxPyEndAllowThreads(__tstate);
21954 if (PyErr_Occurred()) SWIG_fail;
21955 }
21956 Py_INCREF(Py_None); resultobj = Py_None;
21957 return resultobj;
21958 fail:
21959 return NULL;
21960 }
21961
21962
21963 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21964 PyObject *resultobj = NULL;
21965 wxUpdateUIMode arg1 ;
21966 PyObject * obj0 = 0 ;
21967 char *kwnames[] = {
21968 (char *) "mode", NULL
21969 };
21970
21971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21972 {
21973 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
21974 if (SWIG_arg_fail(1)) SWIG_fail;
21975 }
21976 {
21977 PyThreadState* __tstate = wxPyBeginAllowThreads();
21978 wxUpdateUIEvent::SetMode(arg1);
21979
21980 wxPyEndAllowThreads(__tstate);
21981 if (PyErr_Occurred()) SWIG_fail;
21982 }
21983 Py_INCREF(Py_None); resultobj = Py_None;
21984 return resultobj;
21985 fail:
21986 return NULL;
21987 }
21988
21989
21990 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21991 PyObject *resultobj = NULL;
21992 wxUpdateUIMode result;
21993 char *kwnames[] = {
21994 NULL
21995 };
21996
21997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21998 {
21999 PyThreadState* __tstate = wxPyBeginAllowThreads();
22000 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
22001
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 resultobj = SWIG_From_int((result));
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
22013 PyObject *obj;
22014 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22015 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
22016 Py_INCREF(obj);
22017 return Py_BuildValue((char *)"");
22018 }
22019 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22020 PyObject *resultobj = NULL;
22021 wxSysColourChangedEvent *result;
22022 char *kwnames[] = {
22023 NULL
22024 };
22025
22026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22027 {
22028 PyThreadState* __tstate = wxPyBeginAllowThreads();
22029 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22030
22031 wxPyEndAllowThreads(__tstate);
22032 if (PyErr_Occurred()) SWIG_fail;
22033 }
22034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22035 return resultobj;
22036 fail:
22037 return NULL;
22038 }
22039
22040
22041 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22042 PyObject *obj;
22043 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22044 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22045 Py_INCREF(obj);
22046 return Py_BuildValue((char *)"");
22047 }
22048 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22049 PyObject *resultobj = NULL;
22050 int arg1 = (int) 0 ;
22051 wxWindow *arg2 = (wxWindow *) NULL ;
22052 wxMouseCaptureChangedEvent *result;
22053 PyObject * obj0 = 0 ;
22054 PyObject * obj1 = 0 ;
22055 char *kwnames[] = {
22056 (char *) "winid",(char *) "gainedCapture", NULL
22057 };
22058
22059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22060 if (obj0) {
22061 {
22062 arg1 = static_cast<int >(SWIG_As_int(obj0));
22063 if (SWIG_arg_fail(1)) SWIG_fail;
22064 }
22065 }
22066 if (obj1) {
22067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22068 if (SWIG_arg_fail(2)) SWIG_fail;
22069 }
22070 {
22071 PyThreadState* __tstate = wxPyBeginAllowThreads();
22072 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22073
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22085 PyObject *resultobj = NULL;
22086 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22087 wxWindow *result;
22088 PyObject * obj0 = 0 ;
22089 char *kwnames[] = {
22090 (char *) "self", NULL
22091 };
22092
22093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22095 if (SWIG_arg_fail(1)) SWIG_fail;
22096 {
22097 PyThreadState* __tstate = wxPyBeginAllowThreads();
22098 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22099
22100 wxPyEndAllowThreads(__tstate);
22101 if (PyErr_Occurred()) SWIG_fail;
22102 }
22103 {
22104 resultobj = wxPyMake_wxObject(result, (bool)0);
22105 }
22106 return resultobj;
22107 fail:
22108 return NULL;
22109 }
22110
22111
22112 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22113 PyObject *obj;
22114 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22115 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22116 Py_INCREF(obj);
22117 return Py_BuildValue((char *)"");
22118 }
22119 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22120 PyObject *resultobj = NULL;
22121 wxDisplayChangedEvent *result;
22122 char *kwnames[] = {
22123 NULL
22124 };
22125
22126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22127 {
22128 PyThreadState* __tstate = wxPyBeginAllowThreads();
22129 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22130
22131 wxPyEndAllowThreads(__tstate);
22132 if (PyErr_Occurred()) SWIG_fail;
22133 }
22134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22135 return resultobj;
22136 fail:
22137 return NULL;
22138 }
22139
22140
22141 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22142 PyObject *obj;
22143 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22144 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22145 Py_INCREF(obj);
22146 return Py_BuildValue((char *)"");
22147 }
22148 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22149 PyObject *resultobj = NULL;
22150 int arg1 = (int) 0 ;
22151 wxPaletteChangedEvent *result;
22152 PyObject * obj0 = 0 ;
22153 char *kwnames[] = {
22154 (char *) "id", NULL
22155 };
22156
22157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22158 if (obj0) {
22159 {
22160 arg1 = static_cast<int >(SWIG_As_int(obj0));
22161 if (SWIG_arg_fail(1)) SWIG_fail;
22162 }
22163 }
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22167
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22179 PyObject *resultobj = NULL;
22180 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22181 wxWindow *arg2 = (wxWindow *) 0 ;
22182 PyObject * obj0 = 0 ;
22183 PyObject * obj1 = 0 ;
22184 char *kwnames[] = {
22185 (char *) "self",(char *) "win", NULL
22186 };
22187
22188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22190 if (SWIG_arg_fail(1)) SWIG_fail;
22191 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22192 if (SWIG_arg_fail(2)) SWIG_fail;
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 (arg1)->SetChangedWindow(arg2);
22196
22197 wxPyEndAllowThreads(__tstate);
22198 if (PyErr_Occurred()) SWIG_fail;
22199 }
22200 Py_INCREF(Py_None); resultobj = Py_None;
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22208 PyObject *resultobj = NULL;
22209 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22210 wxWindow *result;
22211 PyObject * obj0 = 0 ;
22212 char *kwnames[] = {
22213 (char *) "self", NULL
22214 };
22215
22216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22218 if (SWIG_arg_fail(1)) SWIG_fail;
22219 {
22220 PyThreadState* __tstate = wxPyBeginAllowThreads();
22221 result = (wxWindow *)(arg1)->GetChangedWindow();
22222
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 {
22227 resultobj = wxPyMake_wxObject(result, (bool)0);
22228 }
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22236 PyObject *obj;
22237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22238 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22239 Py_INCREF(obj);
22240 return Py_BuildValue((char *)"");
22241 }
22242 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22243 PyObject *resultobj = NULL;
22244 int arg1 = (int) 0 ;
22245 wxQueryNewPaletteEvent *result;
22246 PyObject * obj0 = 0 ;
22247 char *kwnames[] = {
22248 (char *) "winid", NULL
22249 };
22250
22251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22252 if (obj0) {
22253 {
22254 arg1 = static_cast<int >(SWIG_As_int(obj0));
22255 if (SWIG_arg_fail(1)) SWIG_fail;
22256 }
22257 }
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22261
22262 wxPyEndAllowThreads(__tstate);
22263 if (PyErr_Occurred()) SWIG_fail;
22264 }
22265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22266 return resultobj;
22267 fail:
22268 return NULL;
22269 }
22270
22271
22272 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22273 PyObject *resultobj = NULL;
22274 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22275 bool arg2 ;
22276 PyObject * obj0 = 0 ;
22277 PyObject * obj1 = 0 ;
22278 char *kwnames[] = {
22279 (char *) "self",(char *) "realized", NULL
22280 };
22281
22282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22284 if (SWIG_arg_fail(1)) SWIG_fail;
22285 {
22286 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22287 if (SWIG_arg_fail(2)) SWIG_fail;
22288 }
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 (arg1)->SetPaletteRealized(arg2);
22292
22293 wxPyEndAllowThreads(__tstate);
22294 if (PyErr_Occurred()) SWIG_fail;
22295 }
22296 Py_INCREF(Py_None); resultobj = Py_None;
22297 return resultobj;
22298 fail:
22299 return NULL;
22300 }
22301
22302
22303 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22304 PyObject *resultobj = NULL;
22305 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22306 bool result;
22307 PyObject * obj0 = 0 ;
22308 char *kwnames[] = {
22309 (char *) "self", NULL
22310 };
22311
22312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22314 if (SWIG_arg_fail(1)) SWIG_fail;
22315 {
22316 PyThreadState* __tstate = wxPyBeginAllowThreads();
22317 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22318
22319 wxPyEndAllowThreads(__tstate);
22320 if (PyErr_Occurred()) SWIG_fail;
22321 }
22322 {
22323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22324 }
22325 return resultobj;
22326 fail:
22327 return NULL;
22328 }
22329
22330
22331 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22332 PyObject *obj;
22333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22334 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22335 Py_INCREF(obj);
22336 return Py_BuildValue((char *)"");
22337 }
22338 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22339 PyObject *resultobj = NULL;
22340 wxNavigationKeyEvent *result;
22341 char *kwnames[] = {
22342 NULL
22343 };
22344
22345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22346 {
22347 PyThreadState* __tstate = wxPyBeginAllowThreads();
22348 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22349
22350 wxPyEndAllowThreads(__tstate);
22351 if (PyErr_Occurred()) SWIG_fail;
22352 }
22353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22354 return resultobj;
22355 fail:
22356 return NULL;
22357 }
22358
22359
22360 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22361 PyObject *resultobj = NULL;
22362 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22363 bool result;
22364 PyObject * obj0 = 0 ;
22365 char *kwnames[] = {
22366 (char *) "self", NULL
22367 };
22368
22369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22371 if (SWIG_arg_fail(1)) SWIG_fail;
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22375
22376 wxPyEndAllowThreads(__tstate);
22377 if (PyErr_Occurred()) SWIG_fail;
22378 }
22379 {
22380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22381 }
22382 return resultobj;
22383 fail:
22384 return NULL;
22385 }
22386
22387
22388 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22389 PyObject *resultobj = NULL;
22390 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22391 bool arg2 ;
22392 PyObject * obj0 = 0 ;
22393 PyObject * obj1 = 0 ;
22394 char *kwnames[] = {
22395 (char *) "self",(char *) "forward", NULL
22396 };
22397
22398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22400 if (SWIG_arg_fail(1)) SWIG_fail;
22401 {
22402 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22403 if (SWIG_arg_fail(2)) SWIG_fail;
22404 }
22405 {
22406 PyThreadState* __tstate = wxPyBeginAllowThreads();
22407 (arg1)->SetDirection(arg2);
22408
22409 wxPyEndAllowThreads(__tstate);
22410 if (PyErr_Occurred()) SWIG_fail;
22411 }
22412 Py_INCREF(Py_None); resultobj = Py_None;
22413 return resultobj;
22414 fail:
22415 return NULL;
22416 }
22417
22418
22419 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22420 PyObject *resultobj = NULL;
22421 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22422 bool result;
22423 PyObject * obj0 = 0 ;
22424 char *kwnames[] = {
22425 (char *) "self", NULL
22426 };
22427
22428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22430 if (SWIG_arg_fail(1)) SWIG_fail;
22431 {
22432 PyThreadState* __tstate = wxPyBeginAllowThreads();
22433 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22434
22435 wxPyEndAllowThreads(__tstate);
22436 if (PyErr_Occurred()) SWIG_fail;
22437 }
22438 {
22439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22440 }
22441 return resultobj;
22442 fail:
22443 return NULL;
22444 }
22445
22446
22447 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22448 PyObject *resultobj = NULL;
22449 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22450 bool arg2 ;
22451 PyObject * obj0 = 0 ;
22452 PyObject * obj1 = 0 ;
22453 char *kwnames[] = {
22454 (char *) "self",(char *) "ischange", NULL
22455 };
22456
22457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22459 if (SWIG_arg_fail(1)) SWIG_fail;
22460 {
22461 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22462 if (SWIG_arg_fail(2)) SWIG_fail;
22463 }
22464 {
22465 PyThreadState* __tstate = wxPyBeginAllowThreads();
22466 (arg1)->SetWindowChange(arg2);
22467
22468 wxPyEndAllowThreads(__tstate);
22469 if (PyErr_Occurred()) SWIG_fail;
22470 }
22471 Py_INCREF(Py_None); resultobj = Py_None;
22472 return resultobj;
22473 fail:
22474 return NULL;
22475 }
22476
22477
22478 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22479 PyObject *resultobj = NULL;
22480 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22481 bool result;
22482 PyObject * obj0 = 0 ;
22483 char *kwnames[] = {
22484 (char *) "self", NULL
22485 };
22486
22487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22489 if (SWIG_arg_fail(1)) SWIG_fail;
22490 {
22491 PyThreadState* __tstate = wxPyBeginAllowThreads();
22492 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22493
22494 wxPyEndAllowThreads(__tstate);
22495 if (PyErr_Occurred()) SWIG_fail;
22496 }
22497 {
22498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22499 }
22500 return resultobj;
22501 fail:
22502 return NULL;
22503 }
22504
22505
22506 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22507 PyObject *resultobj = NULL;
22508 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22509 bool arg2 ;
22510 PyObject * obj0 = 0 ;
22511 PyObject * obj1 = 0 ;
22512 char *kwnames[] = {
22513 (char *) "self",(char *) "bIs", NULL
22514 };
22515
22516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22518 if (SWIG_arg_fail(1)) SWIG_fail;
22519 {
22520 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22521 if (SWIG_arg_fail(2)) SWIG_fail;
22522 }
22523 {
22524 PyThreadState* __tstate = wxPyBeginAllowThreads();
22525 (arg1)->SetFromTab(arg2);
22526
22527 wxPyEndAllowThreads(__tstate);
22528 if (PyErr_Occurred()) SWIG_fail;
22529 }
22530 Py_INCREF(Py_None); resultobj = Py_None;
22531 return resultobj;
22532 fail:
22533 return NULL;
22534 }
22535
22536
22537 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22538 PyObject *resultobj = NULL;
22539 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22540 long arg2 ;
22541 PyObject * obj0 = 0 ;
22542 PyObject * obj1 = 0 ;
22543 char *kwnames[] = {
22544 (char *) "self",(char *) "flags", NULL
22545 };
22546
22547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) 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 arg2 = static_cast<long >(SWIG_As_long(obj1));
22552 if (SWIG_arg_fail(2)) SWIG_fail;
22553 }
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 (arg1)->SetFlags(arg2);
22557
22558 wxPyEndAllowThreads(__tstate);
22559 if (PyErr_Occurred()) SWIG_fail;
22560 }
22561 Py_INCREF(Py_None); resultobj = Py_None;
22562 return resultobj;
22563 fail:
22564 return NULL;
22565 }
22566
22567
22568 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22569 PyObject *resultobj = NULL;
22570 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22571 wxWindow *result;
22572 PyObject * obj0 = 0 ;
22573 char *kwnames[] = {
22574 (char *) "self", NULL
22575 };
22576
22577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22579 if (SWIG_arg_fail(1)) SWIG_fail;
22580 {
22581 PyThreadState* __tstate = wxPyBeginAllowThreads();
22582 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22583
22584 wxPyEndAllowThreads(__tstate);
22585 if (PyErr_Occurred()) SWIG_fail;
22586 }
22587 {
22588 resultobj = wxPyMake_wxObject(result, (bool)0);
22589 }
22590 return resultobj;
22591 fail:
22592 return NULL;
22593 }
22594
22595
22596 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22597 PyObject *resultobj = NULL;
22598 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22599 wxWindow *arg2 = (wxWindow *) 0 ;
22600 PyObject * obj0 = 0 ;
22601 PyObject * obj1 = 0 ;
22602 char *kwnames[] = {
22603 (char *) "self",(char *) "win", NULL
22604 };
22605
22606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22608 if (SWIG_arg_fail(1)) SWIG_fail;
22609 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22610 if (SWIG_arg_fail(2)) SWIG_fail;
22611 {
22612 PyThreadState* __tstate = wxPyBeginAllowThreads();
22613 (arg1)->SetCurrentFocus(arg2);
22614
22615 wxPyEndAllowThreads(__tstate);
22616 if (PyErr_Occurred()) SWIG_fail;
22617 }
22618 Py_INCREF(Py_None); resultobj = Py_None;
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22626 PyObject *obj;
22627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22628 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22629 Py_INCREF(obj);
22630 return Py_BuildValue((char *)"");
22631 }
22632 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22633 PyObject *resultobj = NULL;
22634 wxWindow *arg1 = (wxWindow *) NULL ;
22635 wxWindowCreateEvent *result;
22636 PyObject * obj0 = 0 ;
22637 char *kwnames[] = {
22638 (char *) "win", NULL
22639 };
22640
22641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22642 if (obj0) {
22643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22644 if (SWIG_arg_fail(1)) SWIG_fail;
22645 }
22646 {
22647 PyThreadState* __tstate = wxPyBeginAllowThreads();
22648 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22649
22650 wxPyEndAllowThreads(__tstate);
22651 if (PyErr_Occurred()) SWIG_fail;
22652 }
22653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22654 return resultobj;
22655 fail:
22656 return NULL;
22657 }
22658
22659
22660 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22661 PyObject *resultobj = NULL;
22662 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22663 wxWindow *result;
22664 PyObject * obj0 = 0 ;
22665 char *kwnames[] = {
22666 (char *) "self", NULL
22667 };
22668
22669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22671 if (SWIG_arg_fail(1)) SWIG_fail;
22672 {
22673 PyThreadState* __tstate = wxPyBeginAllowThreads();
22674 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22675
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 {
22680 resultobj = wxPyMake_wxObject(result, (bool)0);
22681 }
22682 return resultobj;
22683 fail:
22684 return NULL;
22685 }
22686
22687
22688 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22689 PyObject *obj;
22690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22691 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22692 Py_INCREF(obj);
22693 return Py_BuildValue((char *)"");
22694 }
22695 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22696 PyObject *resultobj = NULL;
22697 wxWindow *arg1 = (wxWindow *) NULL ;
22698 wxWindowDestroyEvent *result;
22699 PyObject * obj0 = 0 ;
22700 char *kwnames[] = {
22701 (char *) "win", NULL
22702 };
22703
22704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22705 if (obj0) {
22706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22707 if (SWIG_arg_fail(1)) SWIG_fail;
22708 }
22709 {
22710 PyThreadState* __tstate = wxPyBeginAllowThreads();
22711 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22712
22713 wxPyEndAllowThreads(__tstate);
22714 if (PyErr_Occurred()) SWIG_fail;
22715 }
22716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22717 return resultobj;
22718 fail:
22719 return NULL;
22720 }
22721
22722
22723 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22724 PyObject *resultobj = NULL;
22725 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22726 wxWindow *result;
22727 PyObject * obj0 = 0 ;
22728 char *kwnames[] = {
22729 (char *) "self", NULL
22730 };
22731
22732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22734 if (SWIG_arg_fail(1)) SWIG_fail;
22735 {
22736 PyThreadState* __tstate = wxPyBeginAllowThreads();
22737 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22738
22739 wxPyEndAllowThreads(__tstate);
22740 if (PyErr_Occurred()) SWIG_fail;
22741 }
22742 {
22743 resultobj = wxPyMake_wxObject(result, (bool)0);
22744 }
22745 return resultobj;
22746 fail:
22747 return NULL;
22748 }
22749
22750
22751 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22752 PyObject *obj;
22753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22754 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22755 Py_INCREF(obj);
22756 return Py_BuildValue((char *)"");
22757 }
22758 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22759 PyObject *resultobj = NULL;
22760 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22761 int arg2 = (int) 0 ;
22762 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22763 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22764 wxContextMenuEvent *result;
22765 wxPoint temp3 ;
22766 PyObject * obj0 = 0 ;
22767 PyObject * obj1 = 0 ;
22768 PyObject * obj2 = 0 ;
22769 char *kwnames[] = {
22770 (char *) "type",(char *) "winid",(char *) "pt", NULL
22771 };
22772
22773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22774 if (obj0) {
22775 {
22776 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22777 if (SWIG_arg_fail(1)) SWIG_fail;
22778 }
22779 }
22780 if (obj1) {
22781 {
22782 arg2 = static_cast<int >(SWIG_As_int(obj1));
22783 if (SWIG_arg_fail(2)) SWIG_fail;
22784 }
22785 }
22786 if (obj2) {
22787 {
22788 arg3 = &temp3;
22789 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22790 }
22791 }
22792 {
22793 PyThreadState* __tstate = wxPyBeginAllowThreads();
22794 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22795
22796 wxPyEndAllowThreads(__tstate);
22797 if (PyErr_Occurred()) SWIG_fail;
22798 }
22799 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22800 return resultobj;
22801 fail:
22802 return NULL;
22803 }
22804
22805
22806 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22807 PyObject *resultobj = NULL;
22808 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22809 wxPoint *result;
22810 PyObject * obj0 = 0 ;
22811 char *kwnames[] = {
22812 (char *) "self", NULL
22813 };
22814
22815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22817 if (SWIG_arg_fail(1)) SWIG_fail;
22818 {
22819 PyThreadState* __tstate = wxPyBeginAllowThreads();
22820 {
22821 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22822 result = (wxPoint *) &_result_ref;
22823 }
22824
22825 wxPyEndAllowThreads(__tstate);
22826 if (PyErr_Occurred()) SWIG_fail;
22827 }
22828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22829 return resultobj;
22830 fail:
22831 return NULL;
22832 }
22833
22834
22835 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22836 PyObject *resultobj = NULL;
22837 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22838 wxPoint *arg2 = 0 ;
22839 wxPoint temp2 ;
22840 PyObject * obj0 = 0 ;
22841 PyObject * obj1 = 0 ;
22842 char *kwnames[] = {
22843 (char *) "self",(char *) "pos", NULL
22844 };
22845
22846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22848 if (SWIG_arg_fail(1)) SWIG_fail;
22849 {
22850 arg2 = &temp2;
22851 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22852 }
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 (arg1)->SetPosition((wxPoint const &)*arg2);
22856
22857 wxPyEndAllowThreads(__tstate);
22858 if (PyErr_Occurred()) SWIG_fail;
22859 }
22860 Py_INCREF(Py_None); resultobj = Py_None;
22861 return resultobj;
22862 fail:
22863 return NULL;
22864 }
22865
22866
22867 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22868 PyObject *obj;
22869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22870 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22871 Py_INCREF(obj);
22872 return Py_BuildValue((char *)"");
22873 }
22874 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22875 PyObject *resultobj = NULL;
22876 wxIdleEvent *result;
22877 char *kwnames[] = {
22878 NULL
22879 };
22880
22881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22882 {
22883 PyThreadState* __tstate = wxPyBeginAllowThreads();
22884 result = (wxIdleEvent *)new wxIdleEvent();
22885
22886 wxPyEndAllowThreads(__tstate);
22887 if (PyErr_Occurred()) SWIG_fail;
22888 }
22889 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22897 PyObject *resultobj = NULL;
22898 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22899 bool arg2 = (bool) true ;
22900 PyObject * obj0 = 0 ;
22901 PyObject * obj1 = 0 ;
22902 char *kwnames[] = {
22903 (char *) "self",(char *) "needMore", NULL
22904 };
22905
22906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22908 if (SWIG_arg_fail(1)) SWIG_fail;
22909 if (obj1) {
22910 {
22911 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22912 if (SWIG_arg_fail(2)) SWIG_fail;
22913 }
22914 }
22915 {
22916 PyThreadState* __tstate = wxPyBeginAllowThreads();
22917 (arg1)->RequestMore(arg2);
22918
22919 wxPyEndAllowThreads(__tstate);
22920 if (PyErr_Occurred()) SWIG_fail;
22921 }
22922 Py_INCREF(Py_None); resultobj = Py_None;
22923 return resultobj;
22924 fail:
22925 return NULL;
22926 }
22927
22928
22929 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22930 PyObject *resultobj = NULL;
22931 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22932 bool result;
22933 PyObject * obj0 = 0 ;
22934 char *kwnames[] = {
22935 (char *) "self", NULL
22936 };
22937
22938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22940 if (SWIG_arg_fail(1)) SWIG_fail;
22941 {
22942 PyThreadState* __tstate = wxPyBeginAllowThreads();
22943 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22944
22945 wxPyEndAllowThreads(__tstate);
22946 if (PyErr_Occurred()) SWIG_fail;
22947 }
22948 {
22949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22950 }
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22958 PyObject *resultobj = NULL;
22959 wxIdleMode arg1 ;
22960 PyObject * obj0 = 0 ;
22961 char *kwnames[] = {
22962 (char *) "mode", NULL
22963 };
22964
22965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22966 {
22967 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
22968 if (SWIG_arg_fail(1)) SWIG_fail;
22969 }
22970 {
22971 PyThreadState* __tstate = wxPyBeginAllowThreads();
22972 wxIdleEvent::SetMode(arg1);
22973
22974 wxPyEndAllowThreads(__tstate);
22975 if (PyErr_Occurred()) SWIG_fail;
22976 }
22977 Py_INCREF(Py_None); resultobj = Py_None;
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22985 PyObject *resultobj = NULL;
22986 wxIdleMode result;
22987 char *kwnames[] = {
22988 NULL
22989 };
22990
22991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22992 {
22993 PyThreadState* __tstate = wxPyBeginAllowThreads();
22994 result = (wxIdleMode)wxIdleEvent::GetMode();
22995
22996 wxPyEndAllowThreads(__tstate);
22997 if (PyErr_Occurred()) SWIG_fail;
22998 }
22999 resultobj = SWIG_From_int((result));
23000 return resultobj;
23001 fail:
23002 return NULL;
23003 }
23004
23005
23006 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
23007 PyObject *resultobj = NULL;
23008 wxWindow *arg1 = (wxWindow *) 0 ;
23009 bool result;
23010 PyObject * obj0 = 0 ;
23011 char *kwnames[] = {
23012 (char *) "win", NULL
23013 };
23014
23015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
23016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23017 if (SWIG_arg_fail(1)) SWIG_fail;
23018 {
23019 PyThreadState* __tstate = wxPyBeginAllowThreads();
23020 result = (bool)wxIdleEvent::CanSend(arg1);
23021
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 {
23026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23027 }
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23035 PyObject *obj;
23036 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23037 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23038 Py_INCREF(obj);
23039 return Py_BuildValue((char *)"");
23040 }
23041 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23042 PyObject *resultobj = NULL;
23043 int arg1 = (int) 0 ;
23044 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23045 wxPyEvent *result;
23046 PyObject * obj0 = 0 ;
23047 PyObject * obj1 = 0 ;
23048 char *kwnames[] = {
23049 (char *) "winid",(char *) "eventType", NULL
23050 };
23051
23052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23053 if (obj0) {
23054 {
23055 arg1 = static_cast<int >(SWIG_As_int(obj0));
23056 if (SWIG_arg_fail(1)) SWIG_fail;
23057 }
23058 }
23059 if (obj1) {
23060 {
23061 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23062 if (SWIG_arg_fail(2)) SWIG_fail;
23063 }
23064 }
23065 {
23066 PyThreadState* __tstate = wxPyBeginAllowThreads();
23067 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23068
23069 wxPyEndAllowThreads(__tstate);
23070 if (PyErr_Occurred()) SWIG_fail;
23071 }
23072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23080 PyObject *resultobj = NULL;
23081 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23082 PyObject * obj0 = 0 ;
23083 char *kwnames[] = {
23084 (char *) "self", NULL
23085 };
23086
23087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23089 if (SWIG_arg_fail(1)) SWIG_fail;
23090 {
23091 PyThreadState* __tstate = wxPyBeginAllowThreads();
23092 delete arg1;
23093
23094 wxPyEndAllowThreads(__tstate);
23095 if (PyErr_Occurred()) SWIG_fail;
23096 }
23097 Py_INCREF(Py_None); resultobj = Py_None;
23098 return resultobj;
23099 fail:
23100 return NULL;
23101 }
23102
23103
23104 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23105 PyObject *resultobj = NULL;
23106 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23107 PyObject *arg2 = (PyObject *) 0 ;
23108 PyObject * obj0 = 0 ;
23109 PyObject * obj1 = 0 ;
23110 char *kwnames[] = {
23111 (char *) "self",(char *) "self", NULL
23112 };
23113
23114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23116 if (SWIG_arg_fail(1)) SWIG_fail;
23117 arg2 = obj1;
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 (arg1)->SetSelf(arg2);
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 Py_INCREF(Py_None); resultobj = Py_None;
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23133 PyObject *resultobj = NULL;
23134 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23135 PyObject *result;
23136 PyObject * obj0 = 0 ;
23137 char *kwnames[] = {
23138 (char *) "self", NULL
23139 };
23140
23141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23143 if (SWIG_arg_fail(1)) SWIG_fail;
23144 {
23145 PyThreadState* __tstate = wxPyBeginAllowThreads();
23146 result = (PyObject *)(arg1)->GetSelf();
23147
23148 wxPyEndAllowThreads(__tstate);
23149 if (PyErr_Occurred()) SWIG_fail;
23150 }
23151 resultobj = result;
23152 return resultobj;
23153 fail:
23154 return NULL;
23155 }
23156
23157
23158 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23159 PyObject *obj;
23160 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23161 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23162 Py_INCREF(obj);
23163 return Py_BuildValue((char *)"");
23164 }
23165 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23166 PyObject *resultobj = NULL;
23167 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23168 int arg2 = (int) 0 ;
23169 wxPyCommandEvent *result;
23170 PyObject * obj0 = 0 ;
23171 PyObject * obj1 = 0 ;
23172 char *kwnames[] = {
23173 (char *) "eventType",(char *) "id", NULL
23174 };
23175
23176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23177 if (obj0) {
23178 {
23179 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23180 if (SWIG_arg_fail(1)) SWIG_fail;
23181 }
23182 }
23183 if (obj1) {
23184 {
23185 arg2 = static_cast<int >(SWIG_As_int(obj1));
23186 if (SWIG_arg_fail(2)) SWIG_fail;
23187 }
23188 }
23189 {
23190 PyThreadState* __tstate = wxPyBeginAllowThreads();
23191 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23192
23193 wxPyEndAllowThreads(__tstate);
23194 if (PyErr_Occurred()) SWIG_fail;
23195 }
23196 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23197 return resultobj;
23198 fail:
23199 return NULL;
23200 }
23201
23202
23203 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23204 PyObject *resultobj = NULL;
23205 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23206 PyObject * obj0 = 0 ;
23207 char *kwnames[] = {
23208 (char *) "self", NULL
23209 };
23210
23211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23213 if (SWIG_arg_fail(1)) SWIG_fail;
23214 {
23215 PyThreadState* __tstate = wxPyBeginAllowThreads();
23216 delete arg1;
23217
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 Py_INCREF(Py_None); resultobj = Py_None;
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23229 PyObject *resultobj = NULL;
23230 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23231 PyObject *arg2 = (PyObject *) 0 ;
23232 PyObject * obj0 = 0 ;
23233 PyObject * obj1 = 0 ;
23234 char *kwnames[] = {
23235 (char *) "self",(char *) "self", NULL
23236 };
23237
23238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23240 if (SWIG_arg_fail(1)) SWIG_fail;
23241 arg2 = obj1;
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 (arg1)->SetSelf(arg2);
23245
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 Py_INCREF(Py_None); resultobj = Py_None;
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj = NULL;
23258 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23259 PyObject *result;
23260 PyObject * obj0 = 0 ;
23261 char *kwnames[] = {
23262 (char *) "self", NULL
23263 };
23264
23265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23267 if (SWIG_arg_fail(1)) SWIG_fail;
23268 {
23269 PyThreadState* __tstate = wxPyBeginAllowThreads();
23270 result = (PyObject *)(arg1)->GetSelf();
23271
23272 wxPyEndAllowThreads(__tstate);
23273 if (PyErr_Occurred()) SWIG_fail;
23274 }
23275 resultobj = result;
23276 return resultobj;
23277 fail:
23278 return NULL;
23279 }
23280
23281
23282 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23283 PyObject *obj;
23284 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23285 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23286 Py_INCREF(obj);
23287 return Py_BuildValue((char *)"");
23288 }
23289 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23290 PyObject *resultobj = NULL;
23291 wxWindow *arg1 = (wxWindow *) 0 ;
23292 wxDateTime *arg2 = 0 ;
23293 wxEventType arg3 ;
23294 wxDateEvent *result;
23295 PyObject * obj0 = 0 ;
23296 PyObject * obj1 = 0 ;
23297 PyObject * obj2 = 0 ;
23298 char *kwnames[] = {
23299 (char *) "win",(char *) "dt",(char *) "type", NULL
23300 };
23301
23302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23304 if (SWIG_arg_fail(1)) SWIG_fail;
23305 {
23306 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(2)) SWIG_fail;
23308 if (arg2 == NULL) {
23309 SWIG_null_ref("wxDateTime");
23310 }
23311 if (SWIG_arg_fail(2)) SWIG_fail;
23312 }
23313 {
23314 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23315 if (SWIG_arg_fail(3)) SWIG_fail;
23316 }
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23320
23321 wxPyEndAllowThreads(__tstate);
23322 if (PyErr_Occurred()) SWIG_fail;
23323 }
23324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj = NULL;
23333 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23334 wxDateTime *result;
23335 PyObject * obj0 = 0 ;
23336 char *kwnames[] = {
23337 (char *) "self", NULL
23338 };
23339
23340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23342 if (SWIG_arg_fail(1)) SWIG_fail;
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 {
23346 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23347 result = (wxDateTime *) &_result_ref;
23348 }
23349
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23354 return resultobj;
23355 fail:
23356 return NULL;
23357 }
23358
23359
23360 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23361 PyObject *resultobj = NULL;
23362 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23363 wxDateTime *arg2 = 0 ;
23364 PyObject * obj0 = 0 ;
23365 PyObject * obj1 = 0 ;
23366 char *kwnames[] = {
23367 (char *) "self",(char *) "date", NULL
23368 };
23369
23370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23372 if (SWIG_arg_fail(1)) SWIG_fail;
23373 {
23374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23375 if (SWIG_arg_fail(2)) SWIG_fail;
23376 if (arg2 == NULL) {
23377 SWIG_null_ref("wxDateTime");
23378 }
23379 if (SWIG_arg_fail(2)) SWIG_fail;
23380 }
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 (arg1)->SetDate((wxDateTime const &)*arg2);
23384
23385 wxPyEndAllowThreads(__tstate);
23386 if (PyErr_Occurred()) SWIG_fail;
23387 }
23388 Py_INCREF(Py_None); resultobj = Py_None;
23389 return resultobj;
23390 fail:
23391 return NULL;
23392 }
23393
23394
23395 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23396 PyObject *obj;
23397 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23398 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23399 Py_INCREF(obj);
23400 return Py_BuildValue((char *)"");
23401 }
23402 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23403 PyObject *resultobj = NULL;
23404 wxPyApp *result;
23405 char *kwnames[] = {
23406 NULL
23407 };
23408
23409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23410 {
23411 PyThreadState* __tstate = wxPyBeginAllowThreads();
23412 result = (wxPyApp *)new_wxPyApp();
23413
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23418 return resultobj;
23419 fail:
23420 return NULL;
23421 }
23422
23423
23424 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23425 PyObject *resultobj = NULL;
23426 wxPyApp *arg1 = (wxPyApp *) 0 ;
23427 PyObject * obj0 = 0 ;
23428 char *kwnames[] = {
23429 (char *) "self", NULL
23430 };
23431
23432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23434 if (SWIG_arg_fail(1)) SWIG_fail;
23435 {
23436 PyThreadState* __tstate = wxPyBeginAllowThreads();
23437 delete arg1;
23438
23439 wxPyEndAllowThreads(__tstate);
23440 if (PyErr_Occurred()) SWIG_fail;
23441 }
23442 Py_INCREF(Py_None); resultobj = Py_None;
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23450 PyObject *resultobj = NULL;
23451 wxPyApp *arg1 = (wxPyApp *) 0 ;
23452 PyObject *arg2 = (PyObject *) 0 ;
23453 PyObject *arg3 = (PyObject *) 0 ;
23454 bool arg4 ;
23455 PyObject * obj0 = 0 ;
23456 PyObject * obj1 = 0 ;
23457 PyObject * obj2 = 0 ;
23458 PyObject * obj3 = 0 ;
23459 char *kwnames[] = {
23460 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23461 };
23462
23463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23465 if (SWIG_arg_fail(1)) SWIG_fail;
23466 arg2 = obj1;
23467 arg3 = obj2;
23468 {
23469 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23470 if (SWIG_arg_fail(4)) SWIG_fail;
23471 }
23472 {
23473 PyThreadState* __tstate = wxPyBeginAllowThreads();
23474 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23475
23476 wxPyEndAllowThreads(__tstate);
23477 if (PyErr_Occurred()) SWIG_fail;
23478 }
23479 Py_INCREF(Py_None); resultobj = Py_None;
23480 return resultobj;
23481 fail:
23482 return NULL;
23483 }
23484
23485
23486 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23487 PyObject *resultobj = NULL;
23488 wxPyApp *arg1 = (wxPyApp *) 0 ;
23489 wxString result;
23490 PyObject * obj0 = 0 ;
23491 char *kwnames[] = {
23492 (char *) "self", NULL
23493 };
23494
23495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23497 if (SWIG_arg_fail(1)) SWIG_fail;
23498 {
23499 PyThreadState* __tstate = wxPyBeginAllowThreads();
23500 result = ((wxPyApp const *)arg1)->GetAppName();
23501
23502 wxPyEndAllowThreads(__tstate);
23503 if (PyErr_Occurred()) SWIG_fail;
23504 }
23505 {
23506 #if wxUSE_UNICODE
23507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23508 #else
23509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23510 #endif
23511 }
23512 return resultobj;
23513 fail:
23514 return NULL;
23515 }
23516
23517
23518 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23519 PyObject *resultobj = NULL;
23520 wxPyApp *arg1 = (wxPyApp *) 0 ;
23521 wxString *arg2 = 0 ;
23522 bool temp2 = false ;
23523 PyObject * obj0 = 0 ;
23524 PyObject * obj1 = 0 ;
23525 char *kwnames[] = {
23526 (char *) "self",(char *) "name", NULL
23527 };
23528
23529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23531 if (SWIG_arg_fail(1)) SWIG_fail;
23532 {
23533 arg2 = wxString_in_helper(obj1);
23534 if (arg2 == NULL) SWIG_fail;
23535 temp2 = true;
23536 }
23537 {
23538 PyThreadState* __tstate = wxPyBeginAllowThreads();
23539 (arg1)->SetAppName((wxString const &)*arg2);
23540
23541 wxPyEndAllowThreads(__tstate);
23542 if (PyErr_Occurred()) SWIG_fail;
23543 }
23544 Py_INCREF(Py_None); resultobj = Py_None;
23545 {
23546 if (temp2)
23547 delete arg2;
23548 }
23549 return resultobj;
23550 fail:
23551 {
23552 if (temp2)
23553 delete arg2;
23554 }
23555 return NULL;
23556 }
23557
23558
23559 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj = NULL;
23561 wxPyApp *arg1 = (wxPyApp *) 0 ;
23562 wxString result;
23563 PyObject * obj0 = 0 ;
23564 char *kwnames[] = {
23565 (char *) "self", NULL
23566 };
23567
23568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23570 if (SWIG_arg_fail(1)) SWIG_fail;
23571 {
23572 PyThreadState* __tstate = wxPyBeginAllowThreads();
23573 result = ((wxPyApp const *)arg1)->GetClassName();
23574
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 {
23579 #if wxUSE_UNICODE
23580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23581 #else
23582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23583 #endif
23584 }
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23592 PyObject *resultobj = NULL;
23593 wxPyApp *arg1 = (wxPyApp *) 0 ;
23594 wxString *arg2 = 0 ;
23595 bool temp2 = false ;
23596 PyObject * obj0 = 0 ;
23597 PyObject * obj1 = 0 ;
23598 char *kwnames[] = {
23599 (char *) "self",(char *) "name", NULL
23600 };
23601
23602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23604 if (SWIG_arg_fail(1)) SWIG_fail;
23605 {
23606 arg2 = wxString_in_helper(obj1);
23607 if (arg2 == NULL) SWIG_fail;
23608 temp2 = true;
23609 }
23610 {
23611 PyThreadState* __tstate = wxPyBeginAllowThreads();
23612 (arg1)->SetClassName((wxString const &)*arg2);
23613
23614 wxPyEndAllowThreads(__tstate);
23615 if (PyErr_Occurred()) SWIG_fail;
23616 }
23617 Py_INCREF(Py_None); resultobj = Py_None;
23618 {
23619 if (temp2)
23620 delete arg2;
23621 }
23622 return resultobj;
23623 fail:
23624 {
23625 if (temp2)
23626 delete arg2;
23627 }
23628 return NULL;
23629 }
23630
23631
23632 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23633 PyObject *resultobj = NULL;
23634 wxPyApp *arg1 = (wxPyApp *) 0 ;
23635 wxString *result;
23636 PyObject * obj0 = 0 ;
23637 char *kwnames[] = {
23638 (char *) "self", NULL
23639 };
23640
23641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23643 if (SWIG_arg_fail(1)) SWIG_fail;
23644 {
23645 PyThreadState* __tstate = wxPyBeginAllowThreads();
23646 {
23647 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23648 result = (wxString *) &_result_ref;
23649 }
23650
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 {
23655 #if wxUSE_UNICODE
23656 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23657 #else
23658 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23659 #endif
23660 }
23661 return resultobj;
23662 fail:
23663 return NULL;
23664 }
23665
23666
23667 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23668 PyObject *resultobj = NULL;
23669 wxPyApp *arg1 = (wxPyApp *) 0 ;
23670 wxString *arg2 = 0 ;
23671 bool temp2 = false ;
23672 PyObject * obj0 = 0 ;
23673 PyObject * obj1 = 0 ;
23674 char *kwnames[] = {
23675 (char *) "self",(char *) "name", NULL
23676 };
23677
23678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23680 if (SWIG_arg_fail(1)) SWIG_fail;
23681 {
23682 arg2 = wxString_in_helper(obj1);
23683 if (arg2 == NULL) SWIG_fail;
23684 temp2 = true;
23685 }
23686 {
23687 PyThreadState* __tstate = wxPyBeginAllowThreads();
23688 (arg1)->SetVendorName((wxString const &)*arg2);
23689
23690 wxPyEndAllowThreads(__tstate);
23691 if (PyErr_Occurred()) SWIG_fail;
23692 }
23693 Py_INCREF(Py_None); resultobj = Py_None;
23694 {
23695 if (temp2)
23696 delete arg2;
23697 }
23698 return resultobj;
23699 fail:
23700 {
23701 if (temp2)
23702 delete arg2;
23703 }
23704 return NULL;
23705 }
23706
23707
23708 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23709 PyObject *resultobj = NULL;
23710 wxPyApp *arg1 = (wxPyApp *) 0 ;
23711 wxAppTraits *result;
23712 PyObject * obj0 = 0 ;
23713 char *kwnames[] = {
23714 (char *) "self", NULL
23715 };
23716
23717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23719 if (SWIG_arg_fail(1)) SWIG_fail;
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 result = (wxAppTraits *)(arg1)->GetTraits();
23723
23724 wxPyEndAllowThreads(__tstate);
23725 if (PyErr_Occurred()) SWIG_fail;
23726 }
23727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23728 return resultobj;
23729 fail:
23730 return NULL;
23731 }
23732
23733
23734 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23735 PyObject *resultobj = NULL;
23736 wxPyApp *arg1 = (wxPyApp *) 0 ;
23737 PyObject * obj0 = 0 ;
23738 char *kwnames[] = {
23739 (char *) "self", NULL
23740 };
23741
23742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23744 if (SWIG_arg_fail(1)) SWIG_fail;
23745 {
23746 PyThreadState* __tstate = wxPyBeginAllowThreads();
23747 (arg1)->ProcessPendingEvents();
23748
23749 wxPyEndAllowThreads(__tstate);
23750 if (PyErr_Occurred()) SWIG_fail;
23751 }
23752 Py_INCREF(Py_None); resultobj = Py_None;
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23760 PyObject *resultobj = NULL;
23761 wxPyApp *arg1 = (wxPyApp *) 0 ;
23762 bool arg2 = (bool) false ;
23763 bool result;
23764 PyObject * obj0 = 0 ;
23765 PyObject * obj1 = 0 ;
23766 char *kwnames[] = {
23767 (char *) "self",(char *) "onlyIfNeeded", NULL
23768 };
23769
23770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23772 if (SWIG_arg_fail(1)) SWIG_fail;
23773 if (obj1) {
23774 {
23775 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23776 if (SWIG_arg_fail(2)) SWIG_fail;
23777 }
23778 }
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 result = (bool)(arg1)->Yield(arg2);
23782
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 {
23787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23788 }
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23796 PyObject *resultobj = NULL;
23797 wxPyApp *arg1 = (wxPyApp *) 0 ;
23798 PyObject * obj0 = 0 ;
23799 char *kwnames[] = {
23800 (char *) "self", NULL
23801 };
23802
23803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23805 if (SWIG_arg_fail(1)) SWIG_fail;
23806 {
23807 PyThreadState* __tstate = wxPyBeginAllowThreads();
23808 (arg1)->WakeUpIdle();
23809
23810 wxPyEndAllowThreads(__tstate);
23811 if (PyErr_Occurred()) SWIG_fail;
23812 }
23813 Py_INCREF(Py_None); resultobj = Py_None;
23814 return resultobj;
23815 fail:
23816 return NULL;
23817 }
23818
23819
23820 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23821 PyObject *resultobj = NULL;
23822 bool result;
23823 char *kwnames[] = {
23824 NULL
23825 };
23826
23827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 result = (bool)wxPyApp::IsMainLoopRunning();
23831
23832 wxPyEndAllowThreads(__tstate);
23833 if (PyErr_Occurred()) SWIG_fail;
23834 }
23835 {
23836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23837 }
23838 return resultobj;
23839 fail:
23840 return NULL;
23841 }
23842
23843
23844 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23845 PyObject *resultobj = NULL;
23846 wxPyApp *arg1 = (wxPyApp *) 0 ;
23847 int result;
23848 PyObject * obj0 = 0 ;
23849 char *kwnames[] = {
23850 (char *) "self", NULL
23851 };
23852
23853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23855 if (SWIG_arg_fail(1)) SWIG_fail;
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 result = (int)(arg1)->MainLoop();
23859
23860 wxPyEndAllowThreads(__tstate);
23861 if (PyErr_Occurred()) SWIG_fail;
23862 }
23863 {
23864 resultobj = SWIG_From_int(static_cast<int >(result));
23865 }
23866 return resultobj;
23867 fail:
23868 return NULL;
23869 }
23870
23871
23872 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23873 PyObject *resultobj = NULL;
23874 wxPyApp *arg1 = (wxPyApp *) 0 ;
23875 PyObject * obj0 = 0 ;
23876 char *kwnames[] = {
23877 (char *) "self", NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23882 if (SWIG_arg_fail(1)) SWIG_fail;
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 (arg1)->Exit();
23886
23887 wxPyEndAllowThreads(__tstate);
23888 if (PyErr_Occurred()) SWIG_fail;
23889 }
23890 Py_INCREF(Py_None); resultobj = Py_None;
23891 return resultobj;
23892 fail:
23893 return NULL;
23894 }
23895
23896
23897 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23898 PyObject *resultobj = NULL;
23899 wxPyApp *arg1 = (wxPyApp *) 0 ;
23900 PyObject * obj0 = 0 ;
23901 char *kwnames[] = {
23902 (char *) "self", NULL
23903 };
23904
23905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23907 if (SWIG_arg_fail(1)) SWIG_fail;
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 (arg1)->ExitMainLoop();
23911
23912 wxPyEndAllowThreads(__tstate);
23913 if (PyErr_Occurred()) SWIG_fail;
23914 }
23915 Py_INCREF(Py_None); resultobj = Py_None;
23916 return resultobj;
23917 fail:
23918 return NULL;
23919 }
23920
23921
23922 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23923 PyObject *resultobj = NULL;
23924 wxPyApp *arg1 = (wxPyApp *) 0 ;
23925 bool result;
23926 PyObject * obj0 = 0 ;
23927 char *kwnames[] = {
23928 (char *) "self", NULL
23929 };
23930
23931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23933 if (SWIG_arg_fail(1)) SWIG_fail;
23934 {
23935 PyThreadState* __tstate = wxPyBeginAllowThreads();
23936 result = (bool)(arg1)->Pending();
23937
23938 wxPyEndAllowThreads(__tstate);
23939 if (PyErr_Occurred()) SWIG_fail;
23940 }
23941 {
23942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23943 }
23944 return resultobj;
23945 fail:
23946 return NULL;
23947 }
23948
23949
23950 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23951 PyObject *resultobj = NULL;
23952 wxPyApp *arg1 = (wxPyApp *) 0 ;
23953 bool result;
23954 PyObject * obj0 = 0 ;
23955 char *kwnames[] = {
23956 (char *) "self", NULL
23957 };
23958
23959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23961 if (SWIG_arg_fail(1)) SWIG_fail;
23962 {
23963 PyThreadState* __tstate = wxPyBeginAllowThreads();
23964 result = (bool)(arg1)->Dispatch();
23965
23966 wxPyEndAllowThreads(__tstate);
23967 if (PyErr_Occurred()) SWIG_fail;
23968 }
23969 {
23970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23971 }
23972 return resultobj;
23973 fail:
23974 return NULL;
23975 }
23976
23977
23978 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23979 PyObject *resultobj = NULL;
23980 wxPyApp *arg1 = (wxPyApp *) 0 ;
23981 bool result;
23982 PyObject * obj0 = 0 ;
23983 char *kwnames[] = {
23984 (char *) "self", NULL
23985 };
23986
23987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23989 if (SWIG_arg_fail(1)) SWIG_fail;
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 result = (bool)(arg1)->ProcessIdle();
23993
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 {
23998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23999 }
24000 return resultobj;
24001 fail:
24002 return NULL;
24003 }
24004
24005
24006 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
24007 PyObject *resultobj = NULL;
24008 wxPyApp *arg1 = (wxPyApp *) 0 ;
24009 wxWindow *arg2 = (wxWindow *) 0 ;
24010 wxIdleEvent *arg3 = 0 ;
24011 bool result;
24012 PyObject * obj0 = 0 ;
24013 PyObject * obj1 = 0 ;
24014 PyObject * obj2 = 0 ;
24015 char *kwnames[] = {
24016 (char *) "self",(char *) "win",(char *) "event", NULL
24017 };
24018
24019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24023 if (SWIG_arg_fail(2)) SWIG_fail;
24024 {
24025 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24026 if (SWIG_arg_fail(3)) SWIG_fail;
24027 if (arg3 == NULL) {
24028 SWIG_null_ref("wxIdleEvent");
24029 }
24030 if (SWIG_arg_fail(3)) SWIG_fail;
24031 }
24032 {
24033 PyThreadState* __tstate = wxPyBeginAllowThreads();
24034 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24035
24036 wxPyEndAllowThreads(__tstate);
24037 if (PyErr_Occurred()) SWIG_fail;
24038 }
24039 {
24040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24041 }
24042 return resultobj;
24043 fail:
24044 return NULL;
24045 }
24046
24047
24048 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24049 PyObject *resultobj = NULL;
24050 wxPyApp *arg1 = (wxPyApp *) 0 ;
24051 bool result;
24052 PyObject * obj0 = 0 ;
24053 char *kwnames[] = {
24054 (char *) "self", NULL
24055 };
24056
24057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24059 if (SWIG_arg_fail(1)) SWIG_fail;
24060 {
24061 PyThreadState* __tstate = wxPyBeginAllowThreads();
24062 result = (bool)((wxPyApp const *)arg1)->IsActive();
24063
24064 wxPyEndAllowThreads(__tstate);
24065 if (PyErr_Occurred()) SWIG_fail;
24066 }
24067 {
24068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24069 }
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj = NULL;
24078 wxPyApp *arg1 = (wxPyApp *) 0 ;
24079 wxWindow *arg2 = (wxWindow *) 0 ;
24080 PyObject * obj0 = 0 ;
24081 PyObject * obj1 = 0 ;
24082 char *kwnames[] = {
24083 (char *) "self",(char *) "win", NULL
24084 };
24085
24086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24088 if (SWIG_arg_fail(1)) SWIG_fail;
24089 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24090 if (SWIG_arg_fail(2)) SWIG_fail;
24091 {
24092 PyThreadState* __tstate = wxPyBeginAllowThreads();
24093 (arg1)->SetTopWindow(arg2);
24094
24095 wxPyEndAllowThreads(__tstate);
24096 if (PyErr_Occurred()) SWIG_fail;
24097 }
24098 Py_INCREF(Py_None); resultobj = Py_None;
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24106 PyObject *resultobj = NULL;
24107 wxPyApp *arg1 = (wxPyApp *) 0 ;
24108 wxWindow *result;
24109 PyObject * obj0 = 0 ;
24110 char *kwnames[] = {
24111 (char *) "self", NULL
24112 };
24113
24114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24116 if (SWIG_arg_fail(1)) SWIG_fail;
24117 {
24118 PyThreadState* __tstate = wxPyBeginAllowThreads();
24119 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24120
24121 wxPyEndAllowThreads(__tstate);
24122 if (PyErr_Occurred()) SWIG_fail;
24123 }
24124 {
24125 resultobj = wxPyMake_wxObject(result, (bool)0);
24126 }
24127 return resultobj;
24128 fail:
24129 return NULL;
24130 }
24131
24132
24133 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24134 PyObject *resultobj = NULL;
24135 wxPyApp *arg1 = (wxPyApp *) 0 ;
24136 bool arg2 ;
24137 PyObject * obj0 = 0 ;
24138 PyObject * obj1 = 0 ;
24139 char *kwnames[] = {
24140 (char *) "self",(char *) "flag", NULL
24141 };
24142
24143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24145 if (SWIG_arg_fail(1)) SWIG_fail;
24146 {
24147 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24148 if (SWIG_arg_fail(2)) SWIG_fail;
24149 }
24150 {
24151 PyThreadState* __tstate = wxPyBeginAllowThreads();
24152 (arg1)->SetExitOnFrameDelete(arg2);
24153
24154 wxPyEndAllowThreads(__tstate);
24155 if (PyErr_Occurred()) SWIG_fail;
24156 }
24157 Py_INCREF(Py_None); resultobj = Py_None;
24158 return resultobj;
24159 fail:
24160 return NULL;
24161 }
24162
24163
24164 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24165 PyObject *resultobj = NULL;
24166 wxPyApp *arg1 = (wxPyApp *) 0 ;
24167 bool result;
24168 PyObject * obj0 = 0 ;
24169 char *kwnames[] = {
24170 (char *) "self", NULL
24171 };
24172
24173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24175 if (SWIG_arg_fail(1)) SWIG_fail;
24176 {
24177 PyThreadState* __tstate = wxPyBeginAllowThreads();
24178 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24179
24180 wxPyEndAllowThreads(__tstate);
24181 if (PyErr_Occurred()) SWIG_fail;
24182 }
24183 {
24184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24185 }
24186 return resultobj;
24187 fail:
24188 return NULL;
24189 }
24190
24191
24192 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24193 PyObject *resultobj = NULL;
24194 wxPyApp *arg1 = (wxPyApp *) 0 ;
24195 bool arg2 ;
24196 PyObject * obj0 = 0 ;
24197 PyObject * obj1 = 0 ;
24198 char *kwnames[] = {
24199 (char *) "self",(char *) "flag", NULL
24200 };
24201
24202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24204 if (SWIG_arg_fail(1)) SWIG_fail;
24205 {
24206 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24207 if (SWIG_arg_fail(2)) SWIG_fail;
24208 }
24209 {
24210 PyThreadState* __tstate = wxPyBeginAllowThreads();
24211 (arg1)->SetUseBestVisual(arg2);
24212
24213 wxPyEndAllowThreads(__tstate);
24214 if (PyErr_Occurred()) SWIG_fail;
24215 }
24216 Py_INCREF(Py_None); resultobj = Py_None;
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj = NULL;
24225 wxPyApp *arg1 = (wxPyApp *) 0 ;
24226 bool result;
24227 PyObject * obj0 = 0 ;
24228 char *kwnames[] = {
24229 (char *) "self", NULL
24230 };
24231
24232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24234 if (SWIG_arg_fail(1)) SWIG_fail;
24235 {
24236 PyThreadState* __tstate = wxPyBeginAllowThreads();
24237 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24238
24239 wxPyEndAllowThreads(__tstate);
24240 if (PyErr_Occurred()) SWIG_fail;
24241 }
24242 {
24243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24244 }
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24252 PyObject *resultobj = NULL;
24253 wxPyApp *arg1 = (wxPyApp *) 0 ;
24254 int arg2 ;
24255 PyObject * obj0 = 0 ;
24256 PyObject * obj1 = 0 ;
24257 char *kwnames[] = {
24258 (char *) "self",(char *) "mode", NULL
24259 };
24260
24261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24263 if (SWIG_arg_fail(1)) SWIG_fail;
24264 {
24265 arg2 = static_cast<int >(SWIG_As_int(obj1));
24266 if (SWIG_arg_fail(2)) SWIG_fail;
24267 }
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 (arg1)->SetPrintMode(arg2);
24271
24272 wxPyEndAllowThreads(__tstate);
24273 if (PyErr_Occurred()) SWIG_fail;
24274 }
24275 Py_INCREF(Py_None); resultobj = Py_None;
24276 return resultobj;
24277 fail:
24278 return NULL;
24279 }
24280
24281
24282 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24283 PyObject *resultobj = NULL;
24284 wxPyApp *arg1 = (wxPyApp *) 0 ;
24285 int result;
24286 PyObject * obj0 = 0 ;
24287 char *kwnames[] = {
24288 (char *) "self", NULL
24289 };
24290
24291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24293 if (SWIG_arg_fail(1)) SWIG_fail;
24294 {
24295 PyThreadState* __tstate = wxPyBeginAllowThreads();
24296 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24297
24298 wxPyEndAllowThreads(__tstate);
24299 if (PyErr_Occurred()) SWIG_fail;
24300 }
24301 {
24302 resultobj = SWIG_From_int(static_cast<int >(result));
24303 }
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24311 PyObject *resultobj = NULL;
24312 wxPyApp *arg1 = (wxPyApp *) 0 ;
24313 int arg2 ;
24314 PyObject * obj0 = 0 ;
24315 PyObject * obj1 = 0 ;
24316 char *kwnames[] = {
24317 (char *) "self",(char *) "mode", NULL
24318 };
24319
24320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24322 if (SWIG_arg_fail(1)) SWIG_fail;
24323 {
24324 arg2 = static_cast<int >(SWIG_As_int(obj1));
24325 if (SWIG_arg_fail(2)) SWIG_fail;
24326 }
24327 {
24328 PyThreadState* __tstate = wxPyBeginAllowThreads();
24329 (arg1)->SetAssertMode(arg2);
24330
24331 wxPyEndAllowThreads(__tstate);
24332 if (PyErr_Occurred()) SWIG_fail;
24333 }
24334 Py_INCREF(Py_None); resultobj = Py_None;
24335 return resultobj;
24336 fail:
24337 return NULL;
24338 }
24339
24340
24341 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24342 PyObject *resultobj = NULL;
24343 wxPyApp *arg1 = (wxPyApp *) 0 ;
24344 int result;
24345 PyObject * obj0 = 0 ;
24346 char *kwnames[] = {
24347 (char *) "self", NULL
24348 };
24349
24350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24352 if (SWIG_arg_fail(1)) SWIG_fail;
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 result = (int)(arg1)->GetAssertMode();
24356
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 {
24361 resultobj = SWIG_From_int(static_cast<int >(result));
24362 }
24363 return resultobj;
24364 fail:
24365 return NULL;
24366 }
24367
24368
24369 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24370 PyObject *resultobj = NULL;
24371 bool result;
24372 char *kwnames[] = {
24373 NULL
24374 };
24375
24376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24377 {
24378 PyThreadState* __tstate = wxPyBeginAllowThreads();
24379 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24380
24381 wxPyEndAllowThreads(__tstate);
24382 if (PyErr_Occurred()) SWIG_fail;
24383 }
24384 {
24385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24386 }
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24394 PyObject *resultobj = NULL;
24395 long result;
24396 char *kwnames[] = {
24397 NULL
24398 };
24399
24400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24401 {
24402 PyThreadState* __tstate = wxPyBeginAllowThreads();
24403 result = (long)wxPyApp::GetMacAboutMenuItemId();
24404
24405 wxPyEndAllowThreads(__tstate);
24406 if (PyErr_Occurred()) SWIG_fail;
24407 }
24408 {
24409 resultobj = SWIG_From_long(static_cast<long >(result));
24410 }
24411 return resultobj;
24412 fail:
24413 return NULL;
24414 }
24415
24416
24417 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24418 PyObject *resultobj = NULL;
24419 long result;
24420 char *kwnames[] = {
24421 NULL
24422 };
24423
24424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24425 {
24426 PyThreadState* __tstate = wxPyBeginAllowThreads();
24427 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24428
24429 wxPyEndAllowThreads(__tstate);
24430 if (PyErr_Occurred()) SWIG_fail;
24431 }
24432 {
24433 resultobj = SWIG_From_long(static_cast<long >(result));
24434 }
24435 return resultobj;
24436 fail:
24437 return NULL;
24438 }
24439
24440
24441 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24442 PyObject *resultobj = NULL;
24443 long result;
24444 char *kwnames[] = {
24445 NULL
24446 };
24447
24448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 result = (long)wxPyApp::GetMacExitMenuItemId();
24452
24453 wxPyEndAllowThreads(__tstate);
24454 if (PyErr_Occurred()) SWIG_fail;
24455 }
24456 {
24457 resultobj = SWIG_From_long(static_cast<long >(result));
24458 }
24459 return resultobj;
24460 fail:
24461 return NULL;
24462 }
24463
24464
24465 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24466 PyObject *resultobj = NULL;
24467 wxString result;
24468 char *kwnames[] = {
24469 NULL
24470 };
24471
24472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = wxPyApp::GetMacHelpMenuTitleName();
24476
24477 wxPyEndAllowThreads(__tstate);
24478 if (PyErr_Occurred()) SWIG_fail;
24479 }
24480 {
24481 #if wxUSE_UNICODE
24482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24483 #else
24484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24485 #endif
24486 }
24487 return resultobj;
24488 fail:
24489 return NULL;
24490 }
24491
24492
24493 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24494 PyObject *resultobj = NULL;
24495 bool arg1 ;
24496 PyObject * obj0 = 0 ;
24497 char *kwnames[] = {
24498 (char *) "val", NULL
24499 };
24500
24501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24502 {
24503 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24504 if (SWIG_arg_fail(1)) SWIG_fail;
24505 }
24506 {
24507 PyThreadState* __tstate = wxPyBeginAllowThreads();
24508 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24509
24510 wxPyEndAllowThreads(__tstate);
24511 if (PyErr_Occurred()) SWIG_fail;
24512 }
24513 Py_INCREF(Py_None); resultobj = Py_None;
24514 return resultobj;
24515 fail:
24516 return NULL;
24517 }
24518
24519
24520 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24521 PyObject *resultobj = NULL;
24522 long arg1 ;
24523 PyObject * obj0 = 0 ;
24524 char *kwnames[] = {
24525 (char *) "val", NULL
24526 };
24527
24528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24529 {
24530 arg1 = static_cast<long >(SWIG_As_long(obj0));
24531 if (SWIG_arg_fail(1)) SWIG_fail;
24532 }
24533 {
24534 PyThreadState* __tstate = wxPyBeginAllowThreads();
24535 wxPyApp::SetMacAboutMenuItemId(arg1);
24536
24537 wxPyEndAllowThreads(__tstate);
24538 if (PyErr_Occurred()) SWIG_fail;
24539 }
24540 Py_INCREF(Py_None); resultobj = Py_None;
24541 return resultobj;
24542 fail:
24543 return NULL;
24544 }
24545
24546
24547 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24548 PyObject *resultobj = NULL;
24549 long arg1 ;
24550 PyObject * obj0 = 0 ;
24551 char *kwnames[] = {
24552 (char *) "val", NULL
24553 };
24554
24555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24556 {
24557 arg1 = static_cast<long >(SWIG_As_long(obj0));
24558 if (SWIG_arg_fail(1)) SWIG_fail;
24559 }
24560 {
24561 PyThreadState* __tstate = wxPyBeginAllowThreads();
24562 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24563
24564 wxPyEndAllowThreads(__tstate);
24565 if (PyErr_Occurred()) SWIG_fail;
24566 }
24567 Py_INCREF(Py_None); resultobj = Py_None;
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24575 PyObject *resultobj = NULL;
24576 long arg1 ;
24577 PyObject * obj0 = 0 ;
24578 char *kwnames[] = {
24579 (char *) "val", NULL
24580 };
24581
24582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24583 {
24584 arg1 = static_cast<long >(SWIG_As_long(obj0));
24585 if (SWIG_arg_fail(1)) SWIG_fail;
24586 }
24587 {
24588 PyThreadState* __tstate = wxPyBeginAllowThreads();
24589 wxPyApp::SetMacExitMenuItemId(arg1);
24590
24591 wxPyEndAllowThreads(__tstate);
24592 if (PyErr_Occurred()) SWIG_fail;
24593 }
24594 Py_INCREF(Py_None); resultobj = Py_None;
24595 return resultobj;
24596 fail:
24597 return NULL;
24598 }
24599
24600
24601 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24602 PyObject *resultobj = NULL;
24603 wxString *arg1 = 0 ;
24604 bool temp1 = false ;
24605 PyObject * obj0 = 0 ;
24606 char *kwnames[] = {
24607 (char *) "val", NULL
24608 };
24609
24610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24611 {
24612 arg1 = wxString_in_helper(obj0);
24613 if (arg1 == NULL) SWIG_fail;
24614 temp1 = true;
24615 }
24616 {
24617 PyThreadState* __tstate = wxPyBeginAllowThreads();
24618 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24619
24620 wxPyEndAllowThreads(__tstate);
24621 if (PyErr_Occurred()) SWIG_fail;
24622 }
24623 Py_INCREF(Py_None); resultobj = Py_None;
24624 {
24625 if (temp1)
24626 delete arg1;
24627 }
24628 return resultobj;
24629 fail:
24630 {
24631 if (temp1)
24632 delete arg1;
24633 }
24634 return NULL;
24635 }
24636
24637
24638 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24639 PyObject *resultobj = NULL;
24640 wxPyApp *arg1 = (wxPyApp *) 0 ;
24641 PyObject * obj0 = 0 ;
24642 char *kwnames[] = {
24643 (char *) "self", NULL
24644 };
24645
24646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24648 if (SWIG_arg_fail(1)) SWIG_fail;
24649 {
24650 PyThreadState* __tstate = wxPyBeginAllowThreads();
24651 (arg1)->_BootstrapApp();
24652
24653 wxPyEndAllowThreads(__tstate);
24654 if (PyErr_Occurred()) SWIG_fail;
24655 }
24656 Py_INCREF(Py_None); resultobj = Py_None;
24657 return resultobj;
24658 fail:
24659 return NULL;
24660 }
24661
24662
24663 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24664 PyObject *resultobj = NULL;
24665 int result;
24666 char *kwnames[] = {
24667 NULL
24668 };
24669
24670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24671 {
24672 PyThreadState* __tstate = wxPyBeginAllowThreads();
24673 result = (int)wxPyApp_GetComCtl32Version();
24674
24675 wxPyEndAllowThreads(__tstate);
24676 if (PyErr_Occurred()) SWIG_fail;
24677 }
24678 {
24679 resultobj = SWIG_From_int(static_cast<int >(result));
24680 }
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24688 PyObject *obj;
24689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24690 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24691 Py_INCREF(obj);
24692 return Py_BuildValue((char *)"");
24693 }
24694 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24695 PyObject *resultobj = NULL;
24696 char *kwnames[] = {
24697 NULL
24698 };
24699
24700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24701 {
24702 PyThreadState* __tstate = wxPyBeginAllowThreads();
24703 wxExit();
24704
24705 wxPyEndAllowThreads(__tstate);
24706 if (PyErr_Occurred()) SWIG_fail;
24707 }
24708 Py_INCREF(Py_None); resultobj = Py_None;
24709 return resultobj;
24710 fail:
24711 return NULL;
24712 }
24713
24714
24715 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24716 PyObject *resultobj = NULL;
24717 bool result;
24718 char *kwnames[] = {
24719 NULL
24720 };
24721
24722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24723 {
24724 PyThreadState* __tstate = wxPyBeginAllowThreads();
24725 result = (bool)wxYield();
24726
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 {
24731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24732 }
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24740 PyObject *resultobj = NULL;
24741 bool result;
24742 char *kwnames[] = {
24743 NULL
24744 };
24745
24746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24747 {
24748 PyThreadState* __tstate = wxPyBeginAllowThreads();
24749 result = (bool)wxYieldIfNeeded();
24750
24751 wxPyEndAllowThreads(__tstate);
24752 if (PyErr_Occurred()) SWIG_fail;
24753 }
24754 {
24755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24756 }
24757 return resultobj;
24758 fail:
24759 return NULL;
24760 }
24761
24762
24763 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24764 PyObject *resultobj = NULL;
24765 wxWindow *arg1 = (wxWindow *) NULL ;
24766 bool arg2 = (bool) false ;
24767 bool result;
24768 PyObject * obj0 = 0 ;
24769 PyObject * obj1 = 0 ;
24770 char *kwnames[] = {
24771 (char *) "win",(char *) "onlyIfNeeded", NULL
24772 };
24773
24774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24775 if (obj0) {
24776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24777 if (SWIG_arg_fail(1)) SWIG_fail;
24778 }
24779 if (obj1) {
24780 {
24781 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24782 if (SWIG_arg_fail(2)) SWIG_fail;
24783 }
24784 }
24785 {
24786 PyThreadState* __tstate = wxPyBeginAllowThreads();
24787 result = (bool)wxSafeYield(arg1,arg2);
24788
24789 wxPyEndAllowThreads(__tstate);
24790 if (PyErr_Occurred()) SWIG_fail;
24791 }
24792 {
24793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24794 }
24795 return resultobj;
24796 fail:
24797 return NULL;
24798 }
24799
24800
24801 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24802 PyObject *resultobj = NULL;
24803 char *kwnames[] = {
24804 NULL
24805 };
24806
24807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 wxWakeUpIdle();
24811
24812 wxPyEndAllowThreads(__tstate);
24813 if (PyErr_Occurred()) SWIG_fail;
24814 }
24815 Py_INCREF(Py_None); resultobj = Py_None;
24816 return resultobj;
24817 fail:
24818 return NULL;
24819 }
24820
24821
24822 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24823 PyObject *resultobj = NULL;
24824 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24825 wxEvent *arg2 = 0 ;
24826 PyObject * obj0 = 0 ;
24827 PyObject * obj1 = 0 ;
24828 char *kwnames[] = {
24829 (char *) "dest",(char *) "event", NULL
24830 };
24831
24832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24834 if (SWIG_arg_fail(1)) SWIG_fail;
24835 {
24836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24837 if (SWIG_arg_fail(2)) SWIG_fail;
24838 if (arg2 == NULL) {
24839 SWIG_null_ref("wxEvent");
24840 }
24841 if (SWIG_arg_fail(2)) SWIG_fail;
24842 }
24843 {
24844 PyThreadState* __tstate = wxPyBeginAllowThreads();
24845 wxPostEvent(arg1,*arg2);
24846
24847 wxPyEndAllowThreads(__tstate);
24848 if (PyErr_Occurred()) SWIG_fail;
24849 }
24850 Py_INCREF(Py_None); resultobj = Py_None;
24851 return resultobj;
24852 fail:
24853 return NULL;
24854 }
24855
24856
24857 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24858 PyObject *resultobj = NULL;
24859 char *kwnames[] = {
24860 NULL
24861 };
24862
24863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 wxApp_CleanUp();
24867
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 Py_INCREF(Py_None); resultobj = Py_None;
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24879 PyObject *resultobj = NULL;
24880 wxPyApp *result;
24881 char *kwnames[] = {
24882 NULL
24883 };
24884
24885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24886 {
24887 PyThreadState* __tstate = wxPyBeginAllowThreads();
24888 result = (wxPyApp *)wxPyGetApp();
24889
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 {
24894 resultobj = wxPyMake_wxObject(result, 0);
24895 }
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24903 PyObject *resultobj = NULL;
24904 char *arg1 = (char *) 0 ;
24905 PyObject * obj0 = 0 ;
24906 char *kwnames[] = {
24907 (char *) "encoding", NULL
24908 };
24909
24910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24911 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24912 SWIG_arg_fail(1);SWIG_fail;
24913 }
24914 {
24915 PyThreadState* __tstate = wxPyBeginAllowThreads();
24916 wxSetDefaultPyEncoding((char const *)arg1);
24917
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 Py_INCREF(Py_None); resultobj = Py_None;
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = NULL;
24930 char *result;
24931 char *kwnames[] = {
24932 NULL
24933 };
24934
24935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24936 {
24937 PyThreadState* __tstate = wxPyBeginAllowThreads();
24938 result = (char *)wxGetDefaultPyEncoding();
24939
24940 wxPyEndAllowThreads(__tstate);
24941 if (PyErr_Occurred()) SWIG_fail;
24942 }
24943 resultobj = SWIG_FromCharPtr(result);
24944 return resultobj;
24945 fail:
24946 return NULL;
24947 }
24948
24949
24950 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24951 PyObject *resultobj = NULL;
24952 wxEventLoop *result;
24953 char *kwnames[] = {
24954 NULL
24955 };
24956
24957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24958 {
24959 PyThreadState* __tstate = wxPyBeginAllowThreads();
24960 result = (wxEventLoop *)new wxEventLoop();
24961
24962 wxPyEndAllowThreads(__tstate);
24963 if (PyErr_Occurred()) SWIG_fail;
24964 }
24965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24973 PyObject *resultobj = NULL;
24974 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24975 PyObject * obj0 = 0 ;
24976 char *kwnames[] = {
24977 (char *) "self", NULL
24978 };
24979
24980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24982 if (SWIG_arg_fail(1)) SWIG_fail;
24983 {
24984 PyThreadState* __tstate = wxPyBeginAllowThreads();
24985 delete arg1;
24986
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 Py_INCREF(Py_None); resultobj = Py_None;
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24998 PyObject *resultobj = NULL;
24999 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25000 int result;
25001 PyObject * obj0 = 0 ;
25002 char *kwnames[] = {
25003 (char *) "self", NULL
25004 };
25005
25006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
25007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25008 if (SWIG_arg_fail(1)) SWIG_fail;
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (int)(arg1)->Run();
25012
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 {
25017 resultobj = SWIG_From_int(static_cast<int >(result));
25018 }
25019 return resultobj;
25020 fail:
25021 return NULL;
25022 }
25023
25024
25025 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25026 PyObject *resultobj = NULL;
25027 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25028 int arg2 = (int) 0 ;
25029 PyObject * obj0 = 0 ;
25030 PyObject * obj1 = 0 ;
25031 char *kwnames[] = {
25032 (char *) "self",(char *) "rc", NULL
25033 };
25034
25035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25037 if (SWIG_arg_fail(1)) SWIG_fail;
25038 if (obj1) {
25039 {
25040 arg2 = static_cast<int >(SWIG_As_int(obj1));
25041 if (SWIG_arg_fail(2)) SWIG_fail;
25042 }
25043 }
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 (arg1)->Exit(arg2);
25047
25048 wxPyEndAllowThreads(__tstate);
25049 if (PyErr_Occurred()) SWIG_fail;
25050 }
25051 Py_INCREF(Py_None); resultobj = Py_None;
25052 return resultobj;
25053 fail:
25054 return NULL;
25055 }
25056
25057
25058 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25059 PyObject *resultobj = NULL;
25060 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25061 bool result;
25062 PyObject * obj0 = 0 ;
25063 char *kwnames[] = {
25064 (char *) "self", NULL
25065 };
25066
25067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25069 if (SWIG_arg_fail(1)) SWIG_fail;
25070 {
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 result = (bool)((wxEventLoop const *)arg1)->Pending();
25073
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 {
25078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25079 }
25080 return resultobj;
25081 fail:
25082 return NULL;
25083 }
25084
25085
25086 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25087 PyObject *resultobj = NULL;
25088 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25089 bool result;
25090 PyObject * obj0 = 0 ;
25091 char *kwnames[] = {
25092 (char *) "self", NULL
25093 };
25094
25095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) 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 {
25099 PyThreadState* __tstate = wxPyBeginAllowThreads();
25100 result = (bool)(arg1)->Dispatch();
25101
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 {
25106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25107 }
25108 return resultobj;
25109 fail:
25110 return NULL;
25111 }
25112
25113
25114 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj = NULL;
25116 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25117 bool result;
25118 PyObject * obj0 = 0 ;
25119 char *kwnames[] = {
25120 (char *) "self", NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(1)) SWIG_fail;
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25129
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 {
25134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25135 }
25136 return resultobj;
25137 fail:
25138 return NULL;
25139 }
25140
25141
25142 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25143 PyObject *resultobj = NULL;
25144 wxEventLoop *result;
25145 char *kwnames[] = {
25146 NULL
25147 };
25148
25149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25150 {
25151 PyThreadState* __tstate = wxPyBeginAllowThreads();
25152 result = (wxEventLoop *)wxEventLoop::GetActive();
25153
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25165 PyObject *resultobj = NULL;
25166 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25167 PyObject * obj0 = 0 ;
25168 char *kwnames[] = {
25169 (char *) "loop", NULL
25170 };
25171
25172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25174 if (SWIG_arg_fail(1)) SWIG_fail;
25175 {
25176 PyThreadState* __tstate = wxPyBeginAllowThreads();
25177 wxEventLoop::SetActive(arg1);
25178
25179 wxPyEndAllowThreads(__tstate);
25180 if (PyErr_Occurred()) SWIG_fail;
25181 }
25182 Py_INCREF(Py_None); resultobj = Py_None;
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25190 PyObject *obj;
25191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25192 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25193 Py_INCREF(obj);
25194 return Py_BuildValue((char *)"");
25195 }
25196 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25197 PyObject *resultobj = NULL;
25198 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25199 wxEventLoopActivator *result;
25200 PyObject * obj0 = 0 ;
25201 char *kwnames[] = {
25202 (char *) "evtLoop", NULL
25203 };
25204
25205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25207 if (SWIG_arg_fail(1)) SWIG_fail;
25208 {
25209 PyThreadState* __tstate = wxPyBeginAllowThreads();
25210 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25211
25212 wxPyEndAllowThreads(__tstate);
25213 if (PyErr_Occurred()) SWIG_fail;
25214 }
25215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25216 return resultobj;
25217 fail:
25218 return NULL;
25219 }
25220
25221
25222 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25223 PyObject *resultobj = NULL;
25224 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25225 PyObject * obj0 = 0 ;
25226 char *kwnames[] = {
25227 (char *) "self", NULL
25228 };
25229
25230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25232 if (SWIG_arg_fail(1)) SWIG_fail;
25233 {
25234 PyThreadState* __tstate = wxPyBeginAllowThreads();
25235 delete arg1;
25236
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 Py_INCREF(Py_None); resultobj = Py_None;
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25248 PyObject *obj;
25249 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25250 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25251 Py_INCREF(obj);
25252 return Py_BuildValue((char *)"");
25253 }
25254 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj = NULL;
25256 int arg1 = (int) 0 ;
25257 int arg2 = (int) 0 ;
25258 int arg3 = (int) 0 ;
25259 wxAcceleratorEntry *result;
25260 PyObject * obj0 = 0 ;
25261 PyObject * obj1 = 0 ;
25262 PyObject * obj2 = 0 ;
25263 char *kwnames[] = {
25264 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25265 };
25266
25267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25268 if (obj0) {
25269 {
25270 arg1 = static_cast<int >(SWIG_As_int(obj0));
25271 if (SWIG_arg_fail(1)) SWIG_fail;
25272 }
25273 }
25274 if (obj1) {
25275 {
25276 arg2 = static_cast<int >(SWIG_As_int(obj1));
25277 if (SWIG_arg_fail(2)) SWIG_fail;
25278 }
25279 }
25280 if (obj2) {
25281 {
25282 arg3 = static_cast<int >(SWIG_As_int(obj2));
25283 if (SWIG_arg_fail(3)) SWIG_fail;
25284 }
25285 }
25286 {
25287 PyThreadState* __tstate = wxPyBeginAllowThreads();
25288 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25289
25290 wxPyEndAllowThreads(__tstate);
25291 if (PyErr_Occurred()) SWIG_fail;
25292 }
25293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25294 return resultobj;
25295 fail:
25296 return NULL;
25297 }
25298
25299
25300 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25301 PyObject *resultobj = NULL;
25302 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25303 PyObject * obj0 = 0 ;
25304 char *kwnames[] = {
25305 (char *) "self", NULL
25306 };
25307
25308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25310 if (SWIG_arg_fail(1)) SWIG_fail;
25311 {
25312 PyThreadState* __tstate = wxPyBeginAllowThreads();
25313 delete arg1;
25314
25315 wxPyEndAllowThreads(__tstate);
25316 if (PyErr_Occurred()) SWIG_fail;
25317 }
25318 Py_INCREF(Py_None); resultobj = Py_None;
25319 return resultobj;
25320 fail:
25321 return NULL;
25322 }
25323
25324
25325 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25326 PyObject *resultobj = NULL;
25327 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25328 int arg2 ;
25329 int arg3 ;
25330 int arg4 ;
25331 PyObject * obj0 = 0 ;
25332 PyObject * obj1 = 0 ;
25333 PyObject * obj2 = 0 ;
25334 PyObject * obj3 = 0 ;
25335 char *kwnames[] = {
25336 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25337 };
25338
25339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25341 if (SWIG_arg_fail(1)) SWIG_fail;
25342 {
25343 arg2 = static_cast<int >(SWIG_As_int(obj1));
25344 if (SWIG_arg_fail(2)) SWIG_fail;
25345 }
25346 {
25347 arg3 = static_cast<int >(SWIG_As_int(obj2));
25348 if (SWIG_arg_fail(3)) SWIG_fail;
25349 }
25350 {
25351 arg4 = static_cast<int >(SWIG_As_int(obj3));
25352 if (SWIG_arg_fail(4)) SWIG_fail;
25353 }
25354 {
25355 PyThreadState* __tstate = wxPyBeginAllowThreads();
25356 (arg1)->Set(arg2,arg3,arg4);
25357
25358 wxPyEndAllowThreads(__tstate);
25359 if (PyErr_Occurred()) SWIG_fail;
25360 }
25361 Py_INCREF(Py_None); resultobj = Py_None;
25362 return resultobj;
25363 fail:
25364 return NULL;
25365 }
25366
25367
25368 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25369 PyObject *resultobj = NULL;
25370 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25371 int result;
25372 PyObject * obj0 = 0 ;
25373 char *kwnames[] = {
25374 (char *) "self", NULL
25375 };
25376
25377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25379 if (SWIG_arg_fail(1)) SWIG_fail;
25380 {
25381 PyThreadState* __tstate = wxPyBeginAllowThreads();
25382 result = (int)(arg1)->GetFlags();
25383
25384 wxPyEndAllowThreads(__tstate);
25385 if (PyErr_Occurred()) SWIG_fail;
25386 }
25387 {
25388 resultobj = SWIG_From_int(static_cast<int >(result));
25389 }
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25397 PyObject *resultobj = NULL;
25398 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25399 int result;
25400 PyObject * obj0 = 0 ;
25401 char *kwnames[] = {
25402 (char *) "self", NULL
25403 };
25404
25405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25407 if (SWIG_arg_fail(1)) SWIG_fail;
25408 {
25409 PyThreadState* __tstate = wxPyBeginAllowThreads();
25410 result = (int)(arg1)->GetKeyCode();
25411
25412 wxPyEndAllowThreads(__tstate);
25413 if (PyErr_Occurred()) SWIG_fail;
25414 }
25415 {
25416 resultobj = SWIG_From_int(static_cast<int >(result));
25417 }
25418 return resultobj;
25419 fail:
25420 return NULL;
25421 }
25422
25423
25424 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25425 PyObject *resultobj = NULL;
25426 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25427 int result;
25428 PyObject * obj0 = 0 ;
25429 char *kwnames[] = {
25430 (char *) "self", NULL
25431 };
25432
25433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25435 if (SWIG_arg_fail(1)) SWIG_fail;
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = (int)(arg1)->GetCommand();
25439
25440 wxPyEndAllowThreads(__tstate);
25441 if (PyErr_Occurred()) SWIG_fail;
25442 }
25443 {
25444 resultobj = SWIG_From_int(static_cast<int >(result));
25445 }
25446 return resultobj;
25447 fail:
25448 return NULL;
25449 }
25450
25451
25452 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25453 PyObject *obj;
25454 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25455 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25456 Py_INCREF(obj);
25457 return Py_BuildValue((char *)"");
25458 }
25459 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25460 PyObject *resultobj = NULL;
25461 int arg1 ;
25462 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25463 wxAcceleratorTable *result;
25464 PyObject * obj0 = 0 ;
25465 char *kwnames[] = {
25466 (char *) "n", NULL
25467 };
25468
25469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25470 {
25471 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25472 if (arg2) arg1 = PyList_Size(obj0);
25473 else arg1 = 0;
25474 }
25475 {
25476 PyThreadState* __tstate = wxPyBeginAllowThreads();
25477 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25478
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25483 {
25484 delete [] arg2;
25485 }
25486 return resultobj;
25487 fail:
25488 {
25489 delete [] arg2;
25490 }
25491 return NULL;
25492 }
25493
25494
25495 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj = NULL;
25497 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25498 PyObject * obj0 = 0 ;
25499 char *kwnames[] = {
25500 (char *) "self", NULL
25501 };
25502
25503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25505 if (SWIG_arg_fail(1)) SWIG_fail;
25506 {
25507 PyThreadState* __tstate = wxPyBeginAllowThreads();
25508 delete arg1;
25509
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 Py_INCREF(Py_None); resultobj = Py_None;
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25521 PyObject *resultobj = NULL;
25522 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25523 bool result;
25524 PyObject * obj0 = 0 ;
25525 char *kwnames[] = {
25526 (char *) "self", NULL
25527 };
25528
25529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25531 if (SWIG_arg_fail(1)) SWIG_fail;
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25535
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 {
25540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25541 }
25542 return resultobj;
25543 fail:
25544 return NULL;
25545 }
25546
25547
25548 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25549 PyObject *obj;
25550 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25551 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25552 Py_INCREF(obj);
25553 return Py_BuildValue((char *)"");
25554 }
25555 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25556 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25557 return 1;
25558 }
25559
25560
25561 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25562 PyObject *pyobj = NULL;
25563
25564 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25565 return pyobj;
25566 }
25567
25568
25569 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25570 PyObject *resultobj = NULL;
25571 wxString *arg1 = 0 ;
25572 wxAcceleratorEntry *result;
25573 bool temp1 = false ;
25574 PyObject * obj0 = 0 ;
25575 char *kwnames[] = {
25576 (char *) "label", NULL
25577 };
25578
25579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25580 {
25581 arg1 = wxString_in_helper(obj0);
25582 if (arg1 == NULL) SWIG_fail;
25583 temp1 = true;
25584 }
25585 {
25586 PyThreadState* __tstate = wxPyBeginAllowThreads();
25587 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25588
25589 wxPyEndAllowThreads(__tstate);
25590 if (PyErr_Occurred()) SWIG_fail;
25591 }
25592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25593 {
25594 if (temp1)
25595 delete arg1;
25596 }
25597 return resultobj;
25598 fail:
25599 {
25600 if (temp1)
25601 delete arg1;
25602 }
25603 return NULL;
25604 }
25605
25606
25607 static int _wrap_PanelNameStr_set(PyObject *) {
25608 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25609 return 1;
25610 }
25611
25612
25613 static PyObject *_wrap_PanelNameStr_get(void) {
25614 PyObject *pyobj = NULL;
25615
25616 {
25617 #if wxUSE_UNICODE
25618 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25619 #else
25620 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25621 #endif
25622 }
25623 return pyobj;
25624 }
25625
25626
25627 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25628 PyObject *resultobj = NULL;
25629 wxVisualAttributes *result;
25630 char *kwnames[] = {
25631 NULL
25632 };
25633
25634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25635 {
25636 PyThreadState* __tstate = wxPyBeginAllowThreads();
25637 result = (wxVisualAttributes *)new_wxVisualAttributes();
25638
25639 wxPyEndAllowThreads(__tstate);
25640 if (PyErr_Occurred()) SWIG_fail;
25641 }
25642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25643 return resultobj;
25644 fail:
25645 return NULL;
25646 }
25647
25648
25649 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25650 PyObject *resultobj = NULL;
25651 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25652 PyObject * obj0 = 0 ;
25653 char *kwnames[] = {
25654 (char *) "self", NULL
25655 };
25656
25657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25659 if (SWIG_arg_fail(1)) SWIG_fail;
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 delete_wxVisualAttributes(arg1);
25663
25664 wxPyEndAllowThreads(__tstate);
25665 if (PyErr_Occurred()) SWIG_fail;
25666 }
25667 Py_INCREF(Py_None); resultobj = Py_None;
25668 return resultobj;
25669 fail:
25670 return NULL;
25671 }
25672
25673
25674 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25675 PyObject *resultobj = NULL;
25676 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25677 wxFont *arg2 = (wxFont *) 0 ;
25678 PyObject * obj0 = 0 ;
25679 PyObject * obj1 = 0 ;
25680 char *kwnames[] = {
25681 (char *) "self",(char *) "font", NULL
25682 };
25683
25684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25686 if (SWIG_arg_fail(1)) SWIG_fail;
25687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25688 if (SWIG_arg_fail(2)) SWIG_fail;
25689 if (arg1) (arg1)->font = *arg2;
25690
25691 Py_INCREF(Py_None); resultobj = Py_None;
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25699 PyObject *resultobj = NULL;
25700 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25701 wxFont *result;
25702 PyObject * obj0 = 0 ;
25703 char *kwnames[] = {
25704 (char *) "self", NULL
25705 };
25706
25707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25709 if (SWIG_arg_fail(1)) SWIG_fail;
25710 result = (wxFont *)& ((arg1)->font);
25711
25712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25713 return resultobj;
25714 fail:
25715 return NULL;
25716 }
25717
25718
25719 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25720 PyObject *resultobj = NULL;
25721 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25722 wxColour *arg2 = (wxColour *) 0 ;
25723 PyObject * obj0 = 0 ;
25724 PyObject * obj1 = 0 ;
25725 char *kwnames[] = {
25726 (char *) "self",(char *) "colFg", NULL
25727 };
25728
25729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25731 if (SWIG_arg_fail(1)) SWIG_fail;
25732 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25733 if (SWIG_arg_fail(2)) SWIG_fail;
25734 if (arg1) (arg1)->colFg = *arg2;
25735
25736 Py_INCREF(Py_None); resultobj = Py_None;
25737 return resultobj;
25738 fail:
25739 return NULL;
25740 }
25741
25742
25743 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25744 PyObject *resultobj = NULL;
25745 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25746 wxColour *result;
25747 PyObject * obj0 = 0 ;
25748 char *kwnames[] = {
25749 (char *) "self", NULL
25750 };
25751
25752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25754 if (SWIG_arg_fail(1)) SWIG_fail;
25755 result = (wxColour *)& ((arg1)->colFg);
25756
25757 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25758 return resultobj;
25759 fail:
25760 return NULL;
25761 }
25762
25763
25764 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25765 PyObject *resultobj = NULL;
25766 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25767 wxColour *arg2 = (wxColour *) 0 ;
25768 PyObject * obj0 = 0 ;
25769 PyObject * obj1 = 0 ;
25770 char *kwnames[] = {
25771 (char *) "self",(char *) "colBg", NULL
25772 };
25773
25774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25776 if (SWIG_arg_fail(1)) SWIG_fail;
25777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25778 if (SWIG_arg_fail(2)) SWIG_fail;
25779 if (arg1) (arg1)->colBg = *arg2;
25780
25781 Py_INCREF(Py_None); resultobj = Py_None;
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25789 PyObject *resultobj = NULL;
25790 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25791 wxColour *result;
25792 PyObject * obj0 = 0 ;
25793 char *kwnames[] = {
25794 (char *) "self", NULL
25795 };
25796
25797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25799 if (SWIG_arg_fail(1)) SWIG_fail;
25800 result = (wxColour *)& ((arg1)->colBg);
25801
25802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25810 PyObject *obj;
25811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25812 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25813 Py_INCREF(obj);
25814 return Py_BuildValue((char *)"");
25815 }
25816 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj = NULL;
25818 wxWindow *arg1 = (wxWindow *) 0 ;
25819 int arg2 = (int) (int)-1 ;
25820 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25821 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25822 wxSize const &arg4_defvalue = wxDefaultSize ;
25823 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25824 long arg5 = (long) 0 ;
25825 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25826 wxString *arg6 = (wxString *) &arg6_defvalue ;
25827 wxWindow *result;
25828 wxPoint temp3 ;
25829 wxSize temp4 ;
25830 bool temp6 = false ;
25831 PyObject * obj0 = 0 ;
25832 PyObject * obj1 = 0 ;
25833 PyObject * obj2 = 0 ;
25834 PyObject * obj3 = 0 ;
25835 PyObject * obj4 = 0 ;
25836 PyObject * obj5 = 0 ;
25837 char *kwnames[] = {
25838 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25839 };
25840
25841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25843 if (SWIG_arg_fail(1)) SWIG_fail;
25844 if (obj1) {
25845 {
25846 arg2 = static_cast<int const >(SWIG_As_int(obj1));
25847 if (SWIG_arg_fail(2)) SWIG_fail;
25848 }
25849 }
25850 if (obj2) {
25851 {
25852 arg3 = &temp3;
25853 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25854 }
25855 }
25856 if (obj3) {
25857 {
25858 arg4 = &temp4;
25859 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25860 }
25861 }
25862 if (obj4) {
25863 {
25864 arg5 = static_cast<long >(SWIG_As_long(obj4));
25865 if (SWIG_arg_fail(5)) SWIG_fail;
25866 }
25867 }
25868 if (obj5) {
25869 {
25870 arg6 = wxString_in_helper(obj5);
25871 if (arg6 == NULL) SWIG_fail;
25872 temp6 = true;
25873 }
25874 }
25875 {
25876 if (!wxPyCheckForApp()) SWIG_fail;
25877 PyThreadState* __tstate = wxPyBeginAllowThreads();
25878 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25879
25880 wxPyEndAllowThreads(__tstate);
25881 if (PyErr_Occurred()) SWIG_fail;
25882 }
25883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25884 {
25885 if (temp6)
25886 delete arg6;
25887 }
25888 return resultobj;
25889 fail:
25890 {
25891 if (temp6)
25892 delete arg6;
25893 }
25894 return NULL;
25895 }
25896
25897
25898 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25899 PyObject *resultobj = NULL;
25900 wxWindow *result;
25901 char *kwnames[] = {
25902 NULL
25903 };
25904
25905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25906 {
25907 if (!wxPyCheckForApp()) SWIG_fail;
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 result = (wxWindow *)new wxWindow();
25910
25911 wxPyEndAllowThreads(__tstate);
25912 if (PyErr_Occurred()) SWIG_fail;
25913 }
25914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25922 PyObject *resultobj = NULL;
25923 wxWindow *arg1 = (wxWindow *) 0 ;
25924 wxWindow *arg2 = (wxWindow *) 0 ;
25925 int arg3 = (int) (int)-1 ;
25926 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25927 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25928 wxSize const &arg5_defvalue = wxDefaultSize ;
25929 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25930 long arg6 = (long) 0 ;
25931 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25932 wxString *arg7 = (wxString *) &arg7_defvalue ;
25933 bool result;
25934 wxPoint temp4 ;
25935 wxSize temp5 ;
25936 bool temp7 = false ;
25937 PyObject * obj0 = 0 ;
25938 PyObject * obj1 = 0 ;
25939 PyObject * obj2 = 0 ;
25940 PyObject * obj3 = 0 ;
25941 PyObject * obj4 = 0 ;
25942 PyObject * obj5 = 0 ;
25943 PyObject * obj6 = 0 ;
25944 char *kwnames[] = {
25945 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25946 };
25947
25948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25950 if (SWIG_arg_fail(1)) SWIG_fail;
25951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25952 if (SWIG_arg_fail(2)) SWIG_fail;
25953 if (obj2) {
25954 {
25955 arg3 = static_cast<int const >(SWIG_As_int(obj2));
25956 if (SWIG_arg_fail(3)) SWIG_fail;
25957 }
25958 }
25959 if (obj3) {
25960 {
25961 arg4 = &temp4;
25962 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25963 }
25964 }
25965 if (obj4) {
25966 {
25967 arg5 = &temp5;
25968 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25969 }
25970 }
25971 if (obj5) {
25972 {
25973 arg6 = static_cast<long >(SWIG_As_long(obj5));
25974 if (SWIG_arg_fail(6)) SWIG_fail;
25975 }
25976 }
25977 if (obj6) {
25978 {
25979 arg7 = wxString_in_helper(obj6);
25980 if (arg7 == NULL) SWIG_fail;
25981 temp7 = true;
25982 }
25983 }
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25987
25988 wxPyEndAllowThreads(__tstate);
25989 if (PyErr_Occurred()) SWIG_fail;
25990 }
25991 {
25992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25993 }
25994 {
25995 if (temp7)
25996 delete arg7;
25997 }
25998 return resultobj;
25999 fail:
26000 {
26001 if (temp7)
26002 delete arg7;
26003 }
26004 return NULL;
26005 }
26006
26007
26008 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
26009 PyObject *resultobj = NULL;
26010 wxWindow *arg1 = (wxWindow *) 0 ;
26011 bool arg2 = (bool) false ;
26012 bool result;
26013 PyObject * obj0 = 0 ;
26014 PyObject * obj1 = 0 ;
26015 char *kwnames[] = {
26016 (char *) "self",(char *) "force", NULL
26017 };
26018
26019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
26020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26021 if (SWIG_arg_fail(1)) SWIG_fail;
26022 if (obj1) {
26023 {
26024 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
26025 if (SWIG_arg_fail(2)) SWIG_fail;
26026 }
26027 }
26028 {
26029 PyThreadState* __tstate = wxPyBeginAllowThreads();
26030 result = (bool)(arg1)->Close(arg2);
26031
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 {
26036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26037 }
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26045 PyObject *resultobj = NULL;
26046 wxWindow *arg1 = (wxWindow *) 0 ;
26047 bool result;
26048 PyObject * obj0 = 0 ;
26049 char *kwnames[] = {
26050 (char *) "self", NULL
26051 };
26052
26053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26055 if (SWIG_arg_fail(1)) SWIG_fail;
26056 {
26057 PyThreadState* __tstate = wxPyBeginAllowThreads();
26058 result = (bool)(arg1)->Destroy();
26059
26060 wxPyEndAllowThreads(__tstate);
26061 if (PyErr_Occurred()) SWIG_fail;
26062 }
26063 {
26064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26065 }
26066 return resultobj;
26067 fail:
26068 return NULL;
26069 }
26070
26071
26072 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26073 PyObject *resultobj = NULL;
26074 wxWindow *arg1 = (wxWindow *) 0 ;
26075 bool result;
26076 PyObject * obj0 = 0 ;
26077 char *kwnames[] = {
26078 (char *) "self", NULL
26079 };
26080
26081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26083 if (SWIG_arg_fail(1)) SWIG_fail;
26084 {
26085 PyThreadState* __tstate = wxPyBeginAllowThreads();
26086 result = (bool)(arg1)->DestroyChildren();
26087
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 {
26092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26093 }
26094 return resultobj;
26095 fail:
26096 return NULL;
26097 }
26098
26099
26100 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj = NULL;
26102 wxWindow *arg1 = (wxWindow *) 0 ;
26103 bool result;
26104 PyObject * obj0 = 0 ;
26105 char *kwnames[] = {
26106 (char *) "self", NULL
26107 };
26108
26109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26111 if (SWIG_arg_fail(1)) SWIG_fail;
26112 {
26113 PyThreadState* __tstate = wxPyBeginAllowThreads();
26114 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26115
26116 wxPyEndAllowThreads(__tstate);
26117 if (PyErr_Occurred()) SWIG_fail;
26118 }
26119 {
26120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26121 }
26122 return resultobj;
26123 fail:
26124 return NULL;
26125 }
26126
26127
26128 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26129 PyObject *resultobj = NULL;
26130 wxWindow *arg1 = (wxWindow *) 0 ;
26131 wxString *arg2 = 0 ;
26132 bool temp2 = false ;
26133 PyObject * obj0 = 0 ;
26134 PyObject * obj1 = 0 ;
26135 char *kwnames[] = {
26136 (char *) "self",(char *) "label", NULL
26137 };
26138
26139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26141 if (SWIG_arg_fail(1)) SWIG_fail;
26142 {
26143 arg2 = wxString_in_helper(obj1);
26144 if (arg2 == NULL) SWIG_fail;
26145 temp2 = true;
26146 }
26147 {
26148 PyThreadState* __tstate = wxPyBeginAllowThreads();
26149 (arg1)->SetLabel((wxString const &)*arg2);
26150
26151 wxPyEndAllowThreads(__tstate);
26152 if (PyErr_Occurred()) SWIG_fail;
26153 }
26154 Py_INCREF(Py_None); resultobj = Py_None;
26155 {
26156 if (temp2)
26157 delete arg2;
26158 }
26159 return resultobj;
26160 fail:
26161 {
26162 if (temp2)
26163 delete arg2;
26164 }
26165 return NULL;
26166 }
26167
26168
26169 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26170 PyObject *resultobj = NULL;
26171 wxWindow *arg1 = (wxWindow *) 0 ;
26172 wxString result;
26173 PyObject * obj0 = 0 ;
26174 char *kwnames[] = {
26175 (char *) "self", NULL
26176 };
26177
26178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26180 if (SWIG_arg_fail(1)) SWIG_fail;
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 result = ((wxWindow const *)arg1)->GetLabel();
26184
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 {
26189 #if wxUSE_UNICODE
26190 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26191 #else
26192 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26193 #endif
26194 }
26195 return resultobj;
26196 fail:
26197 return NULL;
26198 }
26199
26200
26201 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26202 PyObject *resultobj = NULL;
26203 wxWindow *arg1 = (wxWindow *) 0 ;
26204 wxString *arg2 = 0 ;
26205 bool temp2 = false ;
26206 PyObject * obj0 = 0 ;
26207 PyObject * obj1 = 0 ;
26208 char *kwnames[] = {
26209 (char *) "self",(char *) "name", NULL
26210 };
26211
26212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26214 if (SWIG_arg_fail(1)) SWIG_fail;
26215 {
26216 arg2 = wxString_in_helper(obj1);
26217 if (arg2 == NULL) SWIG_fail;
26218 temp2 = true;
26219 }
26220 {
26221 PyThreadState* __tstate = wxPyBeginAllowThreads();
26222 (arg1)->SetName((wxString const &)*arg2);
26223
26224 wxPyEndAllowThreads(__tstate);
26225 if (PyErr_Occurred()) SWIG_fail;
26226 }
26227 Py_INCREF(Py_None); resultobj = Py_None;
26228 {
26229 if (temp2)
26230 delete arg2;
26231 }
26232 return resultobj;
26233 fail:
26234 {
26235 if (temp2)
26236 delete arg2;
26237 }
26238 return NULL;
26239 }
26240
26241
26242 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj = NULL;
26244 wxWindow *arg1 = (wxWindow *) 0 ;
26245 wxString result;
26246 PyObject * obj0 = 0 ;
26247 char *kwnames[] = {
26248 (char *) "self", NULL
26249 };
26250
26251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26253 if (SWIG_arg_fail(1)) SWIG_fail;
26254 {
26255 PyThreadState* __tstate = wxPyBeginAllowThreads();
26256 result = ((wxWindow const *)arg1)->GetName();
26257
26258 wxPyEndAllowThreads(__tstate);
26259 if (PyErr_Occurred()) SWIG_fail;
26260 }
26261 {
26262 #if wxUSE_UNICODE
26263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26264 #else
26265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26266 #endif
26267 }
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26275 PyObject *resultobj = NULL;
26276 wxWindow *arg1 = (wxWindow *) 0 ;
26277 wxWindowVariant arg2 ;
26278 PyObject * obj0 = 0 ;
26279 PyObject * obj1 = 0 ;
26280 char *kwnames[] = {
26281 (char *) "self",(char *) "variant", NULL
26282 };
26283
26284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26286 if (SWIG_arg_fail(1)) SWIG_fail;
26287 {
26288 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26289 if (SWIG_arg_fail(2)) SWIG_fail;
26290 }
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 (arg1)->SetWindowVariant(arg2);
26294
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 Py_INCREF(Py_None); resultobj = Py_None;
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26306 PyObject *resultobj = NULL;
26307 wxWindow *arg1 = (wxWindow *) 0 ;
26308 wxWindowVariant result;
26309 PyObject * obj0 = 0 ;
26310 char *kwnames[] = {
26311 (char *) "self", NULL
26312 };
26313
26314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26316 if (SWIG_arg_fail(1)) SWIG_fail;
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26320
26321 wxPyEndAllowThreads(__tstate);
26322 if (PyErr_Occurred()) SWIG_fail;
26323 }
26324 resultobj = SWIG_From_int((result));
26325 return resultobj;
26326 fail:
26327 return NULL;
26328 }
26329
26330
26331 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26332 PyObject *resultobj = NULL;
26333 wxWindow *arg1 = (wxWindow *) 0 ;
26334 int arg2 ;
26335 PyObject * obj0 = 0 ;
26336 PyObject * obj1 = 0 ;
26337 char *kwnames[] = {
26338 (char *) "self",(char *) "winid", NULL
26339 };
26340
26341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26343 if (SWIG_arg_fail(1)) SWIG_fail;
26344 {
26345 arg2 = static_cast<int >(SWIG_As_int(obj1));
26346 if (SWIG_arg_fail(2)) SWIG_fail;
26347 }
26348 {
26349 PyThreadState* __tstate = wxPyBeginAllowThreads();
26350 (arg1)->SetId(arg2);
26351
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 Py_INCREF(Py_None); resultobj = Py_None;
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26363 PyObject *resultobj = NULL;
26364 wxWindow *arg1 = (wxWindow *) 0 ;
26365 int result;
26366 PyObject * obj0 = 0 ;
26367 char *kwnames[] = {
26368 (char *) "self", NULL
26369 };
26370
26371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26373 if (SWIG_arg_fail(1)) SWIG_fail;
26374 {
26375 PyThreadState* __tstate = wxPyBeginAllowThreads();
26376 result = (int)((wxWindow const *)arg1)->GetId();
26377
26378 wxPyEndAllowThreads(__tstate);
26379 if (PyErr_Occurred()) SWIG_fail;
26380 }
26381 {
26382 resultobj = SWIG_From_int(static_cast<int >(result));
26383 }
26384 return resultobj;
26385 fail:
26386 return NULL;
26387 }
26388
26389
26390 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26391 PyObject *resultobj = NULL;
26392 int result;
26393 char *kwnames[] = {
26394 NULL
26395 };
26396
26397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 result = (int)wxWindow::NewControlId();
26401
26402 wxPyEndAllowThreads(__tstate);
26403 if (PyErr_Occurred()) SWIG_fail;
26404 }
26405 {
26406 resultobj = SWIG_From_int(static_cast<int >(result));
26407 }
26408 return resultobj;
26409 fail:
26410 return NULL;
26411 }
26412
26413
26414 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26415 PyObject *resultobj = NULL;
26416 int arg1 ;
26417 int result;
26418 PyObject * obj0 = 0 ;
26419 char *kwnames[] = {
26420 (char *) "winid", NULL
26421 };
26422
26423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26424 {
26425 arg1 = static_cast<int >(SWIG_As_int(obj0));
26426 if (SWIG_arg_fail(1)) SWIG_fail;
26427 }
26428 {
26429 PyThreadState* __tstate = wxPyBeginAllowThreads();
26430 result = (int)wxWindow::NextControlId(arg1);
26431
26432 wxPyEndAllowThreads(__tstate);
26433 if (PyErr_Occurred()) SWIG_fail;
26434 }
26435 {
26436 resultobj = SWIG_From_int(static_cast<int >(result));
26437 }
26438 return resultobj;
26439 fail:
26440 return NULL;
26441 }
26442
26443
26444 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26445 PyObject *resultobj = NULL;
26446 int arg1 ;
26447 int result;
26448 PyObject * obj0 = 0 ;
26449 char *kwnames[] = {
26450 (char *) "winid", NULL
26451 };
26452
26453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26454 {
26455 arg1 = static_cast<int >(SWIG_As_int(obj0));
26456 if (SWIG_arg_fail(1)) SWIG_fail;
26457 }
26458 {
26459 PyThreadState* __tstate = wxPyBeginAllowThreads();
26460 result = (int)wxWindow::PrevControlId(arg1);
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_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26475 PyObject *resultobj = NULL;
26476 wxWindow *arg1 = (wxWindow *) 0 ;
26477 wxSize *arg2 = 0 ;
26478 wxSize temp2 ;
26479 PyObject * obj0 = 0 ;
26480 PyObject * obj1 = 0 ;
26481 char *kwnames[] = {
26482 (char *) "self",(char *) "size", NULL
26483 };
26484
26485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26487 if (SWIG_arg_fail(1)) SWIG_fail;
26488 {
26489 arg2 = &temp2;
26490 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26491 }
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 (arg1)->SetSize((wxSize const &)*arg2);
26495
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 Py_INCREF(Py_None); resultobj = Py_None;
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26507 PyObject *resultobj = NULL;
26508 wxWindow *arg1 = (wxWindow *) 0 ;
26509 int arg2 ;
26510 int arg3 ;
26511 int arg4 ;
26512 int arg5 ;
26513 int arg6 = (int) wxSIZE_AUTO ;
26514 PyObject * obj0 = 0 ;
26515 PyObject * obj1 = 0 ;
26516 PyObject * obj2 = 0 ;
26517 PyObject * obj3 = 0 ;
26518 PyObject * obj4 = 0 ;
26519 PyObject * obj5 = 0 ;
26520 char *kwnames[] = {
26521 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26522 };
26523
26524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26526 if (SWIG_arg_fail(1)) SWIG_fail;
26527 {
26528 arg2 = static_cast<int >(SWIG_As_int(obj1));
26529 if (SWIG_arg_fail(2)) SWIG_fail;
26530 }
26531 {
26532 arg3 = static_cast<int >(SWIG_As_int(obj2));
26533 if (SWIG_arg_fail(3)) SWIG_fail;
26534 }
26535 {
26536 arg4 = static_cast<int >(SWIG_As_int(obj3));
26537 if (SWIG_arg_fail(4)) SWIG_fail;
26538 }
26539 {
26540 arg5 = static_cast<int >(SWIG_As_int(obj4));
26541 if (SWIG_arg_fail(5)) SWIG_fail;
26542 }
26543 if (obj5) {
26544 {
26545 arg6 = static_cast<int >(SWIG_As_int(obj5));
26546 if (SWIG_arg_fail(6)) SWIG_fail;
26547 }
26548 }
26549 {
26550 PyThreadState* __tstate = wxPyBeginAllowThreads();
26551 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26552
26553 wxPyEndAllowThreads(__tstate);
26554 if (PyErr_Occurred()) SWIG_fail;
26555 }
26556 Py_INCREF(Py_None); resultobj = Py_None;
26557 return resultobj;
26558 fail:
26559 return NULL;
26560 }
26561
26562
26563 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26564 PyObject *resultobj = NULL;
26565 wxWindow *arg1 = (wxWindow *) 0 ;
26566 wxRect *arg2 = 0 ;
26567 int arg3 = (int) wxSIZE_AUTO ;
26568 wxRect temp2 ;
26569 PyObject * obj0 = 0 ;
26570 PyObject * obj1 = 0 ;
26571 PyObject * obj2 = 0 ;
26572 char *kwnames[] = {
26573 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26574 };
26575
26576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26578 if (SWIG_arg_fail(1)) SWIG_fail;
26579 {
26580 arg2 = &temp2;
26581 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26582 }
26583 if (obj2) {
26584 {
26585 arg3 = static_cast<int >(SWIG_As_int(obj2));
26586 if (SWIG_arg_fail(3)) SWIG_fail;
26587 }
26588 }
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26592
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 Py_INCREF(Py_None); resultobj = Py_None;
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26604 PyObject *resultobj = NULL;
26605 wxWindow *arg1 = (wxWindow *) 0 ;
26606 int arg2 ;
26607 int arg3 ;
26608 PyObject * obj0 = 0 ;
26609 PyObject * obj1 = 0 ;
26610 PyObject * obj2 = 0 ;
26611 char *kwnames[] = {
26612 (char *) "self",(char *) "width",(char *) "height", NULL
26613 };
26614
26615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26617 if (SWIG_arg_fail(1)) SWIG_fail;
26618 {
26619 arg2 = static_cast<int >(SWIG_As_int(obj1));
26620 if (SWIG_arg_fail(2)) SWIG_fail;
26621 }
26622 {
26623 arg3 = static_cast<int >(SWIG_As_int(obj2));
26624 if (SWIG_arg_fail(3)) SWIG_fail;
26625 }
26626 {
26627 PyThreadState* __tstate = wxPyBeginAllowThreads();
26628 (arg1)->SetSize(arg2,arg3);
26629
26630 wxPyEndAllowThreads(__tstate);
26631 if (PyErr_Occurred()) SWIG_fail;
26632 }
26633 Py_INCREF(Py_None); resultobj = Py_None;
26634 return resultobj;
26635 fail:
26636 return NULL;
26637 }
26638
26639
26640 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26641 PyObject *resultobj = NULL;
26642 wxWindow *arg1 = (wxWindow *) 0 ;
26643 wxPoint *arg2 = 0 ;
26644 int arg3 = (int) wxSIZE_USE_EXISTING ;
26645 wxPoint temp2 ;
26646 PyObject * obj0 = 0 ;
26647 PyObject * obj1 = 0 ;
26648 PyObject * obj2 = 0 ;
26649 char *kwnames[] = {
26650 (char *) "self",(char *) "pt",(char *) "flags", NULL
26651 };
26652
26653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26655 if (SWIG_arg_fail(1)) SWIG_fail;
26656 {
26657 arg2 = &temp2;
26658 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26659 }
26660 if (obj2) {
26661 {
26662 arg3 = static_cast<int >(SWIG_As_int(obj2));
26663 if (SWIG_arg_fail(3)) SWIG_fail;
26664 }
26665 }
26666 {
26667 PyThreadState* __tstate = wxPyBeginAllowThreads();
26668 (arg1)->Move((wxPoint const &)*arg2,arg3);
26669
26670 wxPyEndAllowThreads(__tstate);
26671 if (PyErr_Occurred()) SWIG_fail;
26672 }
26673 Py_INCREF(Py_None); resultobj = Py_None;
26674 return resultobj;
26675 fail:
26676 return NULL;
26677 }
26678
26679
26680 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26681 PyObject *resultobj = NULL;
26682 wxWindow *arg1 = (wxWindow *) 0 ;
26683 int arg2 ;
26684 int arg3 ;
26685 int arg4 = (int) wxSIZE_USE_EXISTING ;
26686 PyObject * obj0 = 0 ;
26687 PyObject * obj1 = 0 ;
26688 PyObject * obj2 = 0 ;
26689 PyObject * obj3 = 0 ;
26690 char *kwnames[] = {
26691 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26692 };
26693
26694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26696 if (SWIG_arg_fail(1)) SWIG_fail;
26697 {
26698 arg2 = static_cast<int >(SWIG_As_int(obj1));
26699 if (SWIG_arg_fail(2)) SWIG_fail;
26700 }
26701 {
26702 arg3 = static_cast<int >(SWIG_As_int(obj2));
26703 if (SWIG_arg_fail(3)) SWIG_fail;
26704 }
26705 if (obj3) {
26706 {
26707 arg4 = static_cast<int >(SWIG_As_int(obj3));
26708 if (SWIG_arg_fail(4)) SWIG_fail;
26709 }
26710 }
26711 {
26712 PyThreadState* __tstate = wxPyBeginAllowThreads();
26713 (arg1)->Move(arg2,arg3,arg4);
26714
26715 wxPyEndAllowThreads(__tstate);
26716 if (PyErr_Occurred()) SWIG_fail;
26717 }
26718 Py_INCREF(Py_None); resultobj = Py_None;
26719 return resultobj;
26720 fail:
26721 return NULL;
26722 }
26723
26724
26725 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26726 PyObject *resultobj = NULL;
26727 wxWindow *arg1 = (wxWindow *) 0 ;
26728 wxSize const &arg2_defvalue = wxDefaultSize ;
26729 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26730 wxSize temp2 ;
26731 PyObject * obj0 = 0 ;
26732 PyObject * obj1 = 0 ;
26733 char *kwnames[] = {
26734 (char *) "self",(char *) "size", NULL
26735 };
26736
26737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26739 if (SWIG_arg_fail(1)) SWIG_fail;
26740 if (obj1) {
26741 {
26742 arg2 = &temp2;
26743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26744 }
26745 }
26746 {
26747 PyThreadState* __tstate = wxPyBeginAllowThreads();
26748 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26749
26750 wxPyEndAllowThreads(__tstate);
26751 if (PyErr_Occurred()) SWIG_fail;
26752 }
26753 Py_INCREF(Py_None); resultobj = Py_None;
26754 return resultobj;
26755 fail:
26756 return NULL;
26757 }
26758
26759
26760 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26761 PyObject *resultobj = NULL;
26762 wxWindow *arg1 = (wxWindow *) 0 ;
26763 PyObject * obj0 = 0 ;
26764 char *kwnames[] = {
26765 (char *) "self", NULL
26766 };
26767
26768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26770 if (SWIG_arg_fail(1)) SWIG_fail;
26771 {
26772 PyThreadState* __tstate = wxPyBeginAllowThreads();
26773 (arg1)->Raise();
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_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26786 PyObject *resultobj = NULL;
26787 wxWindow *arg1 = (wxWindow *) 0 ;
26788 PyObject * obj0 = 0 ;
26789 char *kwnames[] = {
26790 (char *) "self", NULL
26791 };
26792
26793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26795 if (SWIG_arg_fail(1)) SWIG_fail;
26796 {
26797 PyThreadState* __tstate = wxPyBeginAllowThreads();
26798 (arg1)->Lower();
26799
26800 wxPyEndAllowThreads(__tstate);
26801 if (PyErr_Occurred()) SWIG_fail;
26802 }
26803 Py_INCREF(Py_None); resultobj = Py_None;
26804 return resultobj;
26805 fail:
26806 return NULL;
26807 }
26808
26809
26810 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26811 PyObject *resultobj = NULL;
26812 wxWindow *arg1 = (wxWindow *) 0 ;
26813 wxSize *arg2 = 0 ;
26814 wxSize temp2 ;
26815 PyObject * obj0 = 0 ;
26816 PyObject * obj1 = 0 ;
26817 char *kwnames[] = {
26818 (char *) "self",(char *) "size", NULL
26819 };
26820
26821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26823 if (SWIG_arg_fail(1)) SWIG_fail;
26824 {
26825 arg2 = &temp2;
26826 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26827 }
26828 {
26829 PyThreadState* __tstate = wxPyBeginAllowThreads();
26830 (arg1)->SetClientSize((wxSize const &)*arg2);
26831
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 Py_INCREF(Py_None); resultobj = Py_None;
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26843 PyObject *resultobj = NULL;
26844 wxWindow *arg1 = (wxWindow *) 0 ;
26845 int arg2 ;
26846 int arg3 ;
26847 PyObject * obj0 = 0 ;
26848 PyObject * obj1 = 0 ;
26849 PyObject * obj2 = 0 ;
26850 char *kwnames[] = {
26851 (char *) "self",(char *) "width",(char *) "height", NULL
26852 };
26853
26854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26856 if (SWIG_arg_fail(1)) SWIG_fail;
26857 {
26858 arg2 = static_cast<int >(SWIG_As_int(obj1));
26859 if (SWIG_arg_fail(2)) SWIG_fail;
26860 }
26861 {
26862 arg3 = static_cast<int >(SWIG_As_int(obj2));
26863 if (SWIG_arg_fail(3)) SWIG_fail;
26864 }
26865 {
26866 PyThreadState* __tstate = wxPyBeginAllowThreads();
26867 (arg1)->SetClientSize(arg2,arg3);
26868
26869 wxPyEndAllowThreads(__tstate);
26870 if (PyErr_Occurred()) SWIG_fail;
26871 }
26872 Py_INCREF(Py_None); resultobj = Py_None;
26873 return resultobj;
26874 fail:
26875 return NULL;
26876 }
26877
26878
26879 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26880 PyObject *resultobj = NULL;
26881 wxWindow *arg1 = (wxWindow *) 0 ;
26882 wxRect *arg2 = 0 ;
26883 wxRect temp2 ;
26884 PyObject * obj0 = 0 ;
26885 PyObject * obj1 = 0 ;
26886 char *kwnames[] = {
26887 (char *) "self",(char *) "rect", NULL
26888 };
26889
26890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26892 if (SWIG_arg_fail(1)) SWIG_fail;
26893 {
26894 arg2 = &temp2;
26895 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26896 }
26897 {
26898 PyThreadState* __tstate = wxPyBeginAllowThreads();
26899 (arg1)->SetClientSize((wxRect const &)*arg2);
26900
26901 wxPyEndAllowThreads(__tstate);
26902 if (PyErr_Occurred()) SWIG_fail;
26903 }
26904 Py_INCREF(Py_None); resultobj = Py_None;
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj = NULL;
26913 wxWindow *arg1 = (wxWindow *) 0 ;
26914 wxPoint result;
26915 PyObject * obj0 = 0 ;
26916 char *kwnames[] = {
26917 (char *) "self", NULL
26918 };
26919
26920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26922 if (SWIG_arg_fail(1)) SWIG_fail;
26923 {
26924 PyThreadState* __tstate = wxPyBeginAllowThreads();
26925 result = (arg1)->GetPosition();
26926
26927 wxPyEndAllowThreads(__tstate);
26928 if (PyErr_Occurred()) SWIG_fail;
26929 }
26930 {
26931 wxPoint * resultptr;
26932 resultptr = new wxPoint(static_cast<wxPoint & >(result));
26933 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26934 }
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26942 PyObject *resultobj = NULL;
26943 wxWindow *arg1 = (wxWindow *) 0 ;
26944 int *arg2 = (int *) 0 ;
26945 int *arg3 = (int *) 0 ;
26946 int temp2 ;
26947 int res2 = 0 ;
26948 int temp3 ;
26949 int res3 = 0 ;
26950 PyObject * obj0 = 0 ;
26951 char *kwnames[] = {
26952 (char *) "self", NULL
26953 };
26954
26955 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26956 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26959 if (SWIG_arg_fail(1)) SWIG_fail;
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 (arg1)->GetPosition(arg2,arg3);
26963
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 Py_INCREF(Py_None); resultobj = Py_None;
26968 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26969 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26970 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26971 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26972 return resultobj;
26973 fail:
26974 return NULL;
26975 }
26976
26977
26978 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26979 PyObject *resultobj = NULL;
26980 wxWindow *arg1 = (wxWindow *) 0 ;
26981 wxSize result;
26982 PyObject * obj0 = 0 ;
26983 char *kwnames[] = {
26984 (char *) "self", NULL
26985 };
26986
26987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26989 if (SWIG_arg_fail(1)) SWIG_fail;
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 result = ((wxWindow const *)arg1)->GetSize();
26993
26994 wxPyEndAllowThreads(__tstate);
26995 if (PyErr_Occurred()) SWIG_fail;
26996 }
26997 {
26998 wxSize * resultptr;
26999 resultptr = new wxSize(static_cast<wxSize & >(result));
27000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27001 }
27002 return resultobj;
27003 fail:
27004 return NULL;
27005 }
27006
27007
27008 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27009 PyObject *resultobj = NULL;
27010 wxWindow *arg1 = (wxWindow *) 0 ;
27011 int *arg2 = (int *) 0 ;
27012 int *arg3 = (int *) 0 ;
27013 int temp2 ;
27014 int res2 = 0 ;
27015 int temp3 ;
27016 int res3 = 0 ;
27017 PyObject * obj0 = 0 ;
27018 char *kwnames[] = {
27019 (char *) "self", NULL
27020 };
27021
27022 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27023 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
27025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27026 if (SWIG_arg_fail(1)) SWIG_fail;
27027 {
27028 PyThreadState* __tstate = wxPyBeginAllowThreads();
27029 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27030
27031 wxPyEndAllowThreads(__tstate);
27032 if (PyErr_Occurred()) SWIG_fail;
27033 }
27034 Py_INCREF(Py_None); resultobj = Py_None;
27035 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27036 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27037 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27038 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27046 PyObject *resultobj = NULL;
27047 wxWindow *arg1 = (wxWindow *) 0 ;
27048 wxRect result;
27049 PyObject * obj0 = 0 ;
27050 char *kwnames[] = {
27051 (char *) "self", NULL
27052 };
27053
27054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27056 if (SWIG_arg_fail(1)) SWIG_fail;
27057 {
27058 PyThreadState* __tstate = wxPyBeginAllowThreads();
27059 result = ((wxWindow const *)arg1)->GetRect();
27060
27061 wxPyEndAllowThreads(__tstate);
27062 if (PyErr_Occurred()) SWIG_fail;
27063 }
27064 {
27065 wxRect * resultptr;
27066 resultptr = new wxRect(static_cast<wxRect & >(result));
27067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27068 }
27069 return resultobj;
27070 fail:
27071 return NULL;
27072 }
27073
27074
27075 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27076 PyObject *resultobj = NULL;
27077 wxWindow *arg1 = (wxWindow *) 0 ;
27078 wxSize result;
27079 PyObject * obj0 = 0 ;
27080 char *kwnames[] = {
27081 (char *) "self", NULL
27082 };
27083
27084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",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 result = ((wxWindow const *)arg1)->GetClientSize();
27090
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 {
27095 wxSize * resultptr;
27096 resultptr = new wxSize(static_cast<wxSize & >(result));
27097 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27098 }
27099 return resultobj;
27100 fail:
27101 return NULL;
27102 }
27103
27104
27105 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27106 PyObject *resultobj = NULL;
27107 wxWindow *arg1 = (wxWindow *) 0 ;
27108 int *arg2 = (int *) 0 ;
27109 int *arg3 = (int *) 0 ;
27110 int temp2 ;
27111 int res2 = 0 ;
27112 int temp3 ;
27113 int res3 = 0 ;
27114 PyObject * obj0 = 0 ;
27115 char *kwnames[] = {
27116 (char *) "self", NULL
27117 };
27118
27119 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27120 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27123 if (SWIG_arg_fail(1)) SWIG_fail;
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27127
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 Py_INCREF(Py_None); resultobj = Py_None;
27132 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27133 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27134 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27135 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27136 return resultobj;
27137 fail:
27138 return NULL;
27139 }
27140
27141
27142 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27143 PyObject *resultobj = NULL;
27144 wxWindow *arg1 = (wxWindow *) 0 ;
27145 wxPoint result;
27146 PyObject * obj0 = 0 ;
27147 char *kwnames[] = {
27148 (char *) "self", NULL
27149 };
27150
27151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27153 if (SWIG_arg_fail(1)) SWIG_fail;
27154 {
27155 PyThreadState* __tstate = wxPyBeginAllowThreads();
27156 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27157
27158 wxPyEndAllowThreads(__tstate);
27159 if (PyErr_Occurred()) SWIG_fail;
27160 }
27161 {
27162 wxPoint * resultptr;
27163 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27165 }
27166 return resultobj;
27167 fail:
27168 return NULL;
27169 }
27170
27171
27172 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27173 PyObject *resultobj = NULL;
27174 wxWindow *arg1 = (wxWindow *) 0 ;
27175 wxRect result;
27176 PyObject * obj0 = 0 ;
27177 char *kwnames[] = {
27178 (char *) "self", NULL
27179 };
27180
27181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",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 result = ((wxWindow const *)arg1)->GetClientRect();
27187
27188 wxPyEndAllowThreads(__tstate);
27189 if (PyErr_Occurred()) SWIG_fail;
27190 }
27191 {
27192 wxRect * resultptr;
27193 resultptr = new wxRect(static_cast<wxRect & >(result));
27194 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27195 }
27196 return resultobj;
27197 fail:
27198 return NULL;
27199 }
27200
27201
27202 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27203 PyObject *resultobj = NULL;
27204 wxWindow *arg1 = (wxWindow *) 0 ;
27205 wxSize result;
27206 PyObject * obj0 = 0 ;
27207 char *kwnames[] = {
27208 (char *) "self", NULL
27209 };
27210
27211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",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)->GetBestSize();
27217
27218 wxPyEndAllowThreads(__tstate);
27219 if (PyErr_Occurred()) SWIG_fail;
27220 }
27221 {
27222 wxSize * resultptr;
27223 resultptr = new wxSize(static_cast<wxSize & >(result));
27224 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27225 }
27226 return resultobj;
27227 fail:
27228 return NULL;
27229 }
27230
27231
27232 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27233 PyObject *resultobj = NULL;
27234 wxWindow *arg1 = (wxWindow *) 0 ;
27235 int *arg2 = (int *) 0 ;
27236 int *arg3 = (int *) 0 ;
27237 int temp2 ;
27238 int res2 = 0 ;
27239 int temp3 ;
27240 int res3 = 0 ;
27241 PyObject * obj0 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self", NULL
27244 };
27245
27246 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27247 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27250 if (SWIG_arg_fail(1)) SWIG_fail;
27251 {
27252 PyThreadState* __tstate = wxPyBeginAllowThreads();
27253 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27254
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 Py_INCREF(Py_None); resultobj = Py_None;
27259 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27260 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27261 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27262 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27263 return resultobj;
27264 fail:
27265 return NULL;
27266 }
27267
27268
27269 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27270 PyObject *resultobj = NULL;
27271 wxWindow *arg1 = (wxWindow *) 0 ;
27272 PyObject * obj0 = 0 ;
27273 char *kwnames[] = {
27274 (char *) "self", NULL
27275 };
27276
27277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27279 if (SWIG_arg_fail(1)) SWIG_fail;
27280 {
27281 PyThreadState* __tstate = wxPyBeginAllowThreads();
27282 (arg1)->InvalidateBestSize();
27283
27284 wxPyEndAllowThreads(__tstate);
27285 if (PyErr_Occurred()) SWIG_fail;
27286 }
27287 Py_INCREF(Py_None); resultobj = Py_None;
27288 return resultobj;
27289 fail:
27290 return NULL;
27291 }
27292
27293
27294 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27295 PyObject *resultobj = NULL;
27296 wxWindow *arg1 = (wxWindow *) 0 ;
27297 wxSize *arg2 = 0 ;
27298 wxSize temp2 ;
27299 PyObject * obj0 = 0 ;
27300 PyObject * obj1 = 0 ;
27301 char *kwnames[] = {
27302 (char *) "self",(char *) "size", NULL
27303 };
27304
27305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27307 if (SWIG_arg_fail(1)) SWIG_fail;
27308 {
27309 arg2 = &temp2;
27310 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27311 }
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27315
27316 wxPyEndAllowThreads(__tstate);
27317 if (PyErr_Occurred()) SWIG_fail;
27318 }
27319 Py_INCREF(Py_None); resultobj = Py_None;
27320 return resultobj;
27321 fail:
27322 return NULL;
27323 }
27324
27325
27326 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27327 PyObject *resultobj = NULL;
27328 wxWindow *arg1 = (wxWindow *) 0 ;
27329 wxSize result;
27330 PyObject * obj0 = 0 ;
27331 char *kwnames[] = {
27332 (char *) "self", NULL
27333 };
27334
27335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27337 if (SWIG_arg_fail(1)) SWIG_fail;
27338 {
27339 PyThreadState* __tstate = wxPyBeginAllowThreads();
27340 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27341
27342 wxPyEndAllowThreads(__tstate);
27343 if (PyErr_Occurred()) SWIG_fail;
27344 }
27345 {
27346 wxSize * resultptr;
27347 resultptr = new wxSize(static_cast<wxSize & >(result));
27348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27349 }
27350 return resultobj;
27351 fail:
27352 return NULL;
27353 }
27354
27355
27356 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27357 PyObject *resultobj = NULL;
27358 wxWindow *arg1 = (wxWindow *) 0 ;
27359 wxSize result;
27360 PyObject * obj0 = 0 ;
27361 char *kwnames[] = {
27362 (char *) "self", NULL
27363 };
27364
27365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27367 if (SWIG_arg_fail(1)) SWIG_fail;
27368 {
27369 PyThreadState* __tstate = wxPyBeginAllowThreads();
27370 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27371
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 {
27376 wxSize * resultptr;
27377 resultptr = new wxSize(static_cast<wxSize & >(result));
27378 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27379 }
27380 return resultobj;
27381 fail:
27382 return NULL;
27383 }
27384
27385
27386 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27387 PyObject *resultobj = NULL;
27388 wxWindow *arg1 = (wxWindow *) 0 ;
27389 int arg2 = (int) wxBOTH ;
27390 PyObject * obj0 = 0 ;
27391 PyObject * obj1 = 0 ;
27392 char *kwnames[] = {
27393 (char *) "self",(char *) "direction", NULL
27394 };
27395
27396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27398 if (SWIG_arg_fail(1)) SWIG_fail;
27399 if (obj1) {
27400 {
27401 arg2 = static_cast<int >(SWIG_As_int(obj1));
27402 if (SWIG_arg_fail(2)) SWIG_fail;
27403 }
27404 }
27405 {
27406 PyThreadState* __tstate = wxPyBeginAllowThreads();
27407 (arg1)->Center(arg2);
27408
27409 wxPyEndAllowThreads(__tstate);
27410 if (PyErr_Occurred()) SWIG_fail;
27411 }
27412 Py_INCREF(Py_None); resultobj = Py_None;
27413 return resultobj;
27414 fail:
27415 return NULL;
27416 }
27417
27418
27419 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27420 PyObject *resultobj = NULL;
27421 wxWindow *arg1 = (wxWindow *) 0 ;
27422 int arg2 = (int) wxBOTH ;
27423 PyObject * obj0 = 0 ;
27424 PyObject * obj1 = 0 ;
27425 char *kwnames[] = {
27426 (char *) "self",(char *) "dir", NULL
27427 };
27428
27429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27431 if (SWIG_arg_fail(1)) SWIG_fail;
27432 if (obj1) {
27433 {
27434 arg2 = static_cast<int >(SWIG_As_int(obj1));
27435 if (SWIG_arg_fail(2)) SWIG_fail;
27436 }
27437 }
27438 {
27439 PyThreadState* __tstate = wxPyBeginAllowThreads();
27440 (arg1)->CenterOnScreen(arg2);
27441
27442 wxPyEndAllowThreads(__tstate);
27443 if (PyErr_Occurred()) SWIG_fail;
27444 }
27445 Py_INCREF(Py_None); resultobj = Py_None;
27446 return resultobj;
27447 fail:
27448 return NULL;
27449 }
27450
27451
27452 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27453 PyObject *resultobj = NULL;
27454 wxWindow *arg1 = (wxWindow *) 0 ;
27455 int arg2 = (int) wxBOTH ;
27456 PyObject * obj0 = 0 ;
27457 PyObject * obj1 = 0 ;
27458 char *kwnames[] = {
27459 (char *) "self",(char *) "dir", NULL
27460 };
27461
27462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27464 if (SWIG_arg_fail(1)) SWIG_fail;
27465 if (obj1) {
27466 {
27467 arg2 = static_cast<int >(SWIG_As_int(obj1));
27468 if (SWIG_arg_fail(2)) SWIG_fail;
27469 }
27470 }
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 (arg1)->CenterOnParent(arg2);
27474
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 Py_INCREF(Py_None); resultobj = Py_None;
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj = NULL;
27487 wxWindow *arg1 = (wxWindow *) 0 ;
27488 PyObject * obj0 = 0 ;
27489 char *kwnames[] = {
27490 (char *) "self", NULL
27491 };
27492
27493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27495 if (SWIG_arg_fail(1)) SWIG_fail;
27496 {
27497 PyThreadState* __tstate = wxPyBeginAllowThreads();
27498 (arg1)->Fit();
27499
27500 wxPyEndAllowThreads(__tstate);
27501 if (PyErr_Occurred()) SWIG_fail;
27502 }
27503 Py_INCREF(Py_None); resultobj = Py_None;
27504 return resultobj;
27505 fail:
27506 return NULL;
27507 }
27508
27509
27510 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27511 PyObject *resultobj = NULL;
27512 wxWindow *arg1 = (wxWindow *) 0 ;
27513 PyObject * obj0 = 0 ;
27514 char *kwnames[] = {
27515 (char *) "self", NULL
27516 };
27517
27518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27520 if (SWIG_arg_fail(1)) SWIG_fail;
27521 {
27522 PyThreadState* __tstate = wxPyBeginAllowThreads();
27523 (arg1)->FitInside();
27524
27525 wxPyEndAllowThreads(__tstate);
27526 if (PyErr_Occurred()) SWIG_fail;
27527 }
27528 Py_INCREF(Py_None); resultobj = Py_None;
27529 return resultobj;
27530 fail:
27531 return NULL;
27532 }
27533
27534
27535 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27536 PyObject *resultobj = NULL;
27537 wxWindow *arg1 = (wxWindow *) 0 ;
27538 int arg2 ;
27539 int arg3 ;
27540 int arg4 = (int) -1 ;
27541 int arg5 = (int) -1 ;
27542 int arg6 = (int) -1 ;
27543 int arg7 = (int) -1 ;
27544 PyObject * obj0 = 0 ;
27545 PyObject * obj1 = 0 ;
27546 PyObject * obj2 = 0 ;
27547 PyObject * obj3 = 0 ;
27548 PyObject * obj4 = 0 ;
27549 PyObject * obj5 = 0 ;
27550 PyObject * obj6 = 0 ;
27551 char *kwnames[] = {
27552 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27553 };
27554
27555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27557 if (SWIG_arg_fail(1)) SWIG_fail;
27558 {
27559 arg2 = static_cast<int >(SWIG_As_int(obj1));
27560 if (SWIG_arg_fail(2)) SWIG_fail;
27561 }
27562 {
27563 arg3 = static_cast<int >(SWIG_As_int(obj2));
27564 if (SWIG_arg_fail(3)) SWIG_fail;
27565 }
27566 if (obj3) {
27567 {
27568 arg4 = static_cast<int >(SWIG_As_int(obj3));
27569 if (SWIG_arg_fail(4)) SWIG_fail;
27570 }
27571 }
27572 if (obj4) {
27573 {
27574 arg5 = static_cast<int >(SWIG_As_int(obj4));
27575 if (SWIG_arg_fail(5)) SWIG_fail;
27576 }
27577 }
27578 if (obj5) {
27579 {
27580 arg6 = static_cast<int >(SWIG_As_int(obj5));
27581 if (SWIG_arg_fail(6)) SWIG_fail;
27582 }
27583 }
27584 if (obj6) {
27585 {
27586 arg7 = static_cast<int >(SWIG_As_int(obj6));
27587 if (SWIG_arg_fail(7)) SWIG_fail;
27588 }
27589 }
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27593
27594 wxPyEndAllowThreads(__tstate);
27595 if (PyErr_Occurred()) SWIG_fail;
27596 }
27597 Py_INCREF(Py_None); resultobj = Py_None;
27598 return resultobj;
27599 fail:
27600 return NULL;
27601 }
27602
27603
27604 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27605 PyObject *resultobj = NULL;
27606 wxWindow *arg1 = (wxWindow *) 0 ;
27607 wxSize *arg2 = 0 ;
27608 wxSize const &arg3_defvalue = wxDefaultSize ;
27609 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27610 wxSize const &arg4_defvalue = wxDefaultSize ;
27611 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27612 wxSize temp2 ;
27613 wxSize temp3 ;
27614 wxSize temp4 ;
27615 PyObject * obj0 = 0 ;
27616 PyObject * obj1 = 0 ;
27617 PyObject * obj2 = 0 ;
27618 PyObject * obj3 = 0 ;
27619 char *kwnames[] = {
27620 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27621 };
27622
27623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27625 if (SWIG_arg_fail(1)) SWIG_fail;
27626 {
27627 arg2 = &temp2;
27628 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27629 }
27630 if (obj2) {
27631 {
27632 arg3 = &temp3;
27633 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27634 }
27635 }
27636 if (obj3) {
27637 {
27638 arg4 = &temp4;
27639 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27640 }
27641 }
27642 {
27643 PyThreadState* __tstate = wxPyBeginAllowThreads();
27644 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27645
27646 wxPyEndAllowThreads(__tstate);
27647 if (PyErr_Occurred()) SWIG_fail;
27648 }
27649 Py_INCREF(Py_None); resultobj = Py_None;
27650 return resultobj;
27651 fail:
27652 return NULL;
27653 }
27654
27655
27656 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27657 PyObject *resultobj = NULL;
27658 wxWindow *arg1 = (wxWindow *) 0 ;
27659 int arg2 ;
27660 int arg3 ;
27661 int arg4 = (int) -1 ;
27662 int arg5 = (int) -1 ;
27663 PyObject * obj0 = 0 ;
27664 PyObject * obj1 = 0 ;
27665 PyObject * obj2 = 0 ;
27666 PyObject * obj3 = 0 ;
27667 PyObject * obj4 = 0 ;
27668 char *kwnames[] = {
27669 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27670 };
27671
27672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27674 if (SWIG_arg_fail(1)) SWIG_fail;
27675 {
27676 arg2 = static_cast<int >(SWIG_As_int(obj1));
27677 if (SWIG_arg_fail(2)) SWIG_fail;
27678 }
27679 {
27680 arg3 = static_cast<int >(SWIG_As_int(obj2));
27681 if (SWIG_arg_fail(3)) SWIG_fail;
27682 }
27683 if (obj3) {
27684 {
27685 arg4 = static_cast<int >(SWIG_As_int(obj3));
27686 if (SWIG_arg_fail(4)) SWIG_fail;
27687 }
27688 }
27689 if (obj4) {
27690 {
27691 arg5 = static_cast<int >(SWIG_As_int(obj4));
27692 if (SWIG_arg_fail(5)) SWIG_fail;
27693 }
27694 }
27695 {
27696 PyThreadState* __tstate = wxPyBeginAllowThreads();
27697 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27698
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 Py_INCREF(Py_None); resultobj = Py_None;
27703 return resultobj;
27704 fail:
27705 return NULL;
27706 }
27707
27708
27709 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27710 PyObject *resultobj = NULL;
27711 wxWindow *arg1 = (wxWindow *) 0 ;
27712 wxSize *arg2 = 0 ;
27713 wxSize const &arg3_defvalue = wxDefaultSize ;
27714 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27715 wxSize temp2 ;
27716 wxSize temp3 ;
27717 PyObject * obj0 = 0 ;
27718 PyObject * obj1 = 0 ;
27719 PyObject * obj2 = 0 ;
27720 char *kwnames[] = {
27721 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27722 };
27723
27724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27726 if (SWIG_arg_fail(1)) SWIG_fail;
27727 {
27728 arg2 = &temp2;
27729 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27730 }
27731 if (obj2) {
27732 {
27733 arg3 = &temp3;
27734 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27735 }
27736 }
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27740
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 Py_INCREF(Py_None); resultobj = Py_None;
27745 return resultobj;
27746 fail:
27747 return NULL;
27748 }
27749
27750
27751 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27752 PyObject *resultobj = NULL;
27753 wxWindow *arg1 = (wxWindow *) 0 ;
27754 wxSize result;
27755 PyObject * obj0 = 0 ;
27756 char *kwnames[] = {
27757 (char *) "self", NULL
27758 };
27759
27760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27762 if (SWIG_arg_fail(1)) SWIG_fail;
27763 {
27764 PyThreadState* __tstate = wxPyBeginAllowThreads();
27765 result = ((wxWindow const *)arg1)->GetMaxSize();
27766
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 {
27771 wxSize * resultptr;
27772 resultptr = new wxSize(static_cast<wxSize & >(result));
27773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27774 }
27775 return resultobj;
27776 fail:
27777 return NULL;
27778 }
27779
27780
27781 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27782 PyObject *resultobj = NULL;
27783 wxWindow *arg1 = (wxWindow *) 0 ;
27784 wxSize result;
27785 PyObject * obj0 = 0 ;
27786 char *kwnames[] = {
27787 (char *) "self", NULL
27788 };
27789
27790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27792 if (SWIG_arg_fail(1)) SWIG_fail;
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = ((wxWindow const *)arg1)->GetMinSize();
27796
27797 wxPyEndAllowThreads(__tstate);
27798 if (PyErr_Occurred()) SWIG_fail;
27799 }
27800 {
27801 wxSize * resultptr;
27802 resultptr = new wxSize(static_cast<wxSize & >(result));
27803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27804 }
27805 return resultobj;
27806 fail:
27807 return NULL;
27808 }
27809
27810
27811 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27812 PyObject *resultobj = NULL;
27813 wxWindow *arg1 = (wxWindow *) 0 ;
27814 wxSize *arg2 = 0 ;
27815 wxSize temp2 ;
27816 PyObject * obj0 = 0 ;
27817 PyObject * obj1 = 0 ;
27818 char *kwnames[] = {
27819 (char *) "self",(char *) "minSize", NULL
27820 };
27821
27822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27824 if (SWIG_arg_fail(1)) SWIG_fail;
27825 {
27826 arg2 = &temp2;
27827 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27828 }
27829 {
27830 PyThreadState* __tstate = wxPyBeginAllowThreads();
27831 (arg1)->SetMinSize((wxSize const &)*arg2);
27832
27833 wxPyEndAllowThreads(__tstate);
27834 if (PyErr_Occurred()) SWIG_fail;
27835 }
27836 Py_INCREF(Py_None); resultobj = Py_None;
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27844 PyObject *resultobj = NULL;
27845 wxWindow *arg1 = (wxWindow *) 0 ;
27846 wxSize *arg2 = 0 ;
27847 wxSize temp2 ;
27848 PyObject * obj0 = 0 ;
27849 PyObject * obj1 = 0 ;
27850 char *kwnames[] = {
27851 (char *) "self",(char *) "maxSize", NULL
27852 };
27853
27854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27856 if (SWIG_arg_fail(1)) SWIG_fail;
27857 {
27858 arg2 = &temp2;
27859 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27860 }
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 (arg1)->SetMaxSize((wxSize const &)*arg2);
27864
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 Py_INCREF(Py_None); resultobj = Py_None;
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27876 PyObject *resultobj = NULL;
27877 wxWindow *arg1 = (wxWindow *) 0 ;
27878 int result;
27879 PyObject * obj0 = 0 ;
27880 char *kwnames[] = {
27881 (char *) "self", NULL
27882 };
27883
27884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27886 if (SWIG_arg_fail(1)) SWIG_fail;
27887 {
27888 PyThreadState* __tstate = wxPyBeginAllowThreads();
27889 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27890
27891 wxPyEndAllowThreads(__tstate);
27892 if (PyErr_Occurred()) SWIG_fail;
27893 }
27894 {
27895 resultobj = SWIG_From_int(static_cast<int >(result));
27896 }
27897 return resultobj;
27898 fail:
27899 return NULL;
27900 }
27901
27902
27903 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27904 PyObject *resultobj = NULL;
27905 wxWindow *arg1 = (wxWindow *) 0 ;
27906 int result;
27907 PyObject * obj0 = 0 ;
27908 char *kwnames[] = {
27909 (char *) "self", NULL
27910 };
27911
27912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27914 if (SWIG_arg_fail(1)) SWIG_fail;
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27918
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 {
27923 resultobj = SWIG_From_int(static_cast<int >(result));
27924 }
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27932 PyObject *resultobj = NULL;
27933 wxWindow *arg1 = (wxWindow *) 0 ;
27934 int result;
27935 PyObject * obj0 = 0 ;
27936 char *kwnames[] = {
27937 (char *) "self", NULL
27938 };
27939
27940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27942 if (SWIG_arg_fail(1)) SWIG_fail;
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27946
27947 wxPyEndAllowThreads(__tstate);
27948 if (PyErr_Occurred()) SWIG_fail;
27949 }
27950 {
27951 resultobj = SWIG_From_int(static_cast<int >(result));
27952 }
27953 return resultobj;
27954 fail:
27955 return NULL;
27956 }
27957
27958
27959 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27960 PyObject *resultobj = NULL;
27961 wxWindow *arg1 = (wxWindow *) 0 ;
27962 int result;
27963 PyObject * obj0 = 0 ;
27964 char *kwnames[] = {
27965 (char *) "self", NULL
27966 };
27967
27968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27970 if (SWIG_arg_fail(1)) SWIG_fail;
27971 {
27972 PyThreadState* __tstate = wxPyBeginAllowThreads();
27973 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27974
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 {
27979 resultobj = SWIG_From_int(static_cast<int >(result));
27980 }
27981 return resultobj;
27982 fail:
27983 return NULL;
27984 }
27985
27986
27987 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27988 PyObject *resultobj = NULL;
27989 wxWindow *arg1 = (wxWindow *) 0 ;
27990 wxSize *arg2 = 0 ;
27991 wxSize temp2 ;
27992 PyObject * obj0 = 0 ;
27993 PyObject * obj1 = 0 ;
27994 char *kwnames[] = {
27995 (char *) "self",(char *) "size", NULL
27996 };
27997
27998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28000 if (SWIG_arg_fail(1)) SWIG_fail;
28001 {
28002 arg2 = &temp2;
28003 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28004 }
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 (arg1)->SetVirtualSize((wxSize const &)*arg2);
28008
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 Py_INCREF(Py_None); resultobj = Py_None;
28013 return resultobj;
28014 fail:
28015 return NULL;
28016 }
28017
28018
28019 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
28020 PyObject *resultobj = NULL;
28021 wxWindow *arg1 = (wxWindow *) 0 ;
28022 int arg2 ;
28023 int arg3 ;
28024 PyObject * obj0 = 0 ;
28025 PyObject * obj1 = 0 ;
28026 PyObject * obj2 = 0 ;
28027 char *kwnames[] = {
28028 (char *) "self",(char *) "w",(char *) "h", NULL
28029 };
28030
28031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28033 if (SWIG_arg_fail(1)) SWIG_fail;
28034 {
28035 arg2 = static_cast<int >(SWIG_As_int(obj1));
28036 if (SWIG_arg_fail(2)) SWIG_fail;
28037 }
28038 {
28039 arg3 = static_cast<int >(SWIG_As_int(obj2));
28040 if (SWIG_arg_fail(3)) SWIG_fail;
28041 }
28042 {
28043 PyThreadState* __tstate = wxPyBeginAllowThreads();
28044 (arg1)->SetVirtualSize(arg2,arg3);
28045
28046 wxPyEndAllowThreads(__tstate);
28047 if (PyErr_Occurred()) SWIG_fail;
28048 }
28049 Py_INCREF(Py_None); resultobj = Py_None;
28050 return resultobj;
28051 fail:
28052 return NULL;
28053 }
28054
28055
28056 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28057 PyObject *resultobj = NULL;
28058 wxWindow *arg1 = (wxWindow *) 0 ;
28059 wxSize result;
28060 PyObject * obj0 = 0 ;
28061 char *kwnames[] = {
28062 (char *) "self", NULL
28063 };
28064
28065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28067 if (SWIG_arg_fail(1)) SWIG_fail;
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 result = ((wxWindow const *)arg1)->GetVirtualSize();
28071
28072 wxPyEndAllowThreads(__tstate);
28073 if (PyErr_Occurred()) SWIG_fail;
28074 }
28075 {
28076 wxSize * resultptr;
28077 resultptr = new wxSize(static_cast<wxSize & >(result));
28078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28079 }
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28087 PyObject *resultobj = NULL;
28088 wxWindow *arg1 = (wxWindow *) 0 ;
28089 int *arg2 = (int *) 0 ;
28090 int *arg3 = (int *) 0 ;
28091 int temp2 ;
28092 int res2 = 0 ;
28093 int temp3 ;
28094 int res3 = 0 ;
28095 PyObject * obj0 = 0 ;
28096 char *kwnames[] = {
28097 (char *) "self", NULL
28098 };
28099
28100 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28101 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28104 if (SWIG_arg_fail(1)) SWIG_fail;
28105 {
28106 PyThreadState* __tstate = wxPyBeginAllowThreads();
28107 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28108
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 Py_INCREF(Py_None); resultobj = Py_None;
28113 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28114 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28115 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28116 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28124 PyObject *resultobj = NULL;
28125 wxWindow *arg1 = (wxWindow *) 0 ;
28126 wxSize result;
28127 PyObject * obj0 = 0 ;
28128 char *kwnames[] = {
28129 (char *) "self", NULL
28130 };
28131
28132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28134 if (SWIG_arg_fail(1)) SWIG_fail;
28135 {
28136 PyThreadState* __tstate = wxPyBeginAllowThreads();
28137 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28138
28139 wxPyEndAllowThreads(__tstate);
28140 if (PyErr_Occurred()) SWIG_fail;
28141 }
28142 {
28143 wxSize * resultptr;
28144 resultptr = new wxSize(static_cast<wxSize & >(result));
28145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28146 }
28147 return resultobj;
28148 fail:
28149 return NULL;
28150 }
28151
28152
28153 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28154 PyObject *resultobj = NULL;
28155 wxWindow *arg1 = (wxWindow *) 0 ;
28156 bool arg2 = (bool) true ;
28157 bool result;
28158 PyObject * obj0 = 0 ;
28159 PyObject * obj1 = 0 ;
28160 char *kwnames[] = {
28161 (char *) "self",(char *) "show", NULL
28162 };
28163
28164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28166 if (SWIG_arg_fail(1)) SWIG_fail;
28167 if (obj1) {
28168 {
28169 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28170 if (SWIG_arg_fail(2)) SWIG_fail;
28171 }
28172 }
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (bool)(arg1)->Show(arg2);
28176
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 {
28181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28182 }
28183 return resultobj;
28184 fail:
28185 return NULL;
28186 }
28187
28188
28189 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28190 PyObject *resultobj = NULL;
28191 wxWindow *arg1 = (wxWindow *) 0 ;
28192 bool result;
28193 PyObject * obj0 = 0 ;
28194 char *kwnames[] = {
28195 (char *) "self", NULL
28196 };
28197
28198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28200 if (SWIG_arg_fail(1)) SWIG_fail;
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 result = (bool)(arg1)->Hide();
28204
28205 wxPyEndAllowThreads(__tstate);
28206 if (PyErr_Occurred()) SWIG_fail;
28207 }
28208 {
28209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28210 }
28211 return resultobj;
28212 fail:
28213 return NULL;
28214 }
28215
28216
28217 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28218 PyObject *resultobj = NULL;
28219 wxWindow *arg1 = (wxWindow *) 0 ;
28220 bool arg2 = (bool) true ;
28221 bool result;
28222 PyObject * obj0 = 0 ;
28223 PyObject * obj1 = 0 ;
28224 char *kwnames[] = {
28225 (char *) "self",(char *) "enable", NULL
28226 };
28227
28228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28230 if (SWIG_arg_fail(1)) SWIG_fail;
28231 if (obj1) {
28232 {
28233 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28234 if (SWIG_arg_fail(2)) SWIG_fail;
28235 }
28236 }
28237 {
28238 PyThreadState* __tstate = wxPyBeginAllowThreads();
28239 result = (bool)(arg1)->Enable(arg2);
28240
28241 wxPyEndAllowThreads(__tstate);
28242 if (PyErr_Occurred()) SWIG_fail;
28243 }
28244 {
28245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28246 }
28247 return resultobj;
28248 fail:
28249 return NULL;
28250 }
28251
28252
28253 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28254 PyObject *resultobj = NULL;
28255 wxWindow *arg1 = (wxWindow *) 0 ;
28256 bool result;
28257 PyObject * obj0 = 0 ;
28258 char *kwnames[] = {
28259 (char *) "self", NULL
28260 };
28261
28262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28264 if (SWIG_arg_fail(1)) SWIG_fail;
28265 {
28266 PyThreadState* __tstate = wxPyBeginAllowThreads();
28267 result = (bool)(arg1)->Disable();
28268
28269 wxPyEndAllowThreads(__tstate);
28270 if (PyErr_Occurred()) SWIG_fail;
28271 }
28272 {
28273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28274 }
28275 return resultobj;
28276 fail:
28277 return NULL;
28278 }
28279
28280
28281 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28282 PyObject *resultobj = NULL;
28283 wxWindow *arg1 = (wxWindow *) 0 ;
28284 bool result;
28285 PyObject * obj0 = 0 ;
28286 char *kwnames[] = {
28287 (char *) "self", NULL
28288 };
28289
28290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28292 if (SWIG_arg_fail(1)) SWIG_fail;
28293 {
28294 PyThreadState* __tstate = wxPyBeginAllowThreads();
28295 result = (bool)((wxWindow const *)arg1)->IsShown();
28296
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 {
28301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28302 }
28303 return resultobj;
28304 fail:
28305 return NULL;
28306 }
28307
28308
28309 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28310 PyObject *resultobj = NULL;
28311 wxWindow *arg1 = (wxWindow *) 0 ;
28312 bool result;
28313 PyObject * obj0 = 0 ;
28314 char *kwnames[] = {
28315 (char *) "self", NULL
28316 };
28317
28318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28320 if (SWIG_arg_fail(1)) SWIG_fail;
28321 {
28322 PyThreadState* __tstate = wxPyBeginAllowThreads();
28323 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28324
28325 wxPyEndAllowThreads(__tstate);
28326 if (PyErr_Occurred()) SWIG_fail;
28327 }
28328 {
28329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28330 }
28331 return resultobj;
28332 fail:
28333 return NULL;
28334 }
28335
28336
28337 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28338 PyObject *resultobj = NULL;
28339 wxWindow *arg1 = (wxWindow *) 0 ;
28340 long arg2 ;
28341 PyObject * obj0 = 0 ;
28342 PyObject * obj1 = 0 ;
28343 char *kwnames[] = {
28344 (char *) "self",(char *) "style", NULL
28345 };
28346
28347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28349 if (SWIG_arg_fail(1)) SWIG_fail;
28350 {
28351 arg2 = static_cast<long >(SWIG_As_long(obj1));
28352 if (SWIG_arg_fail(2)) SWIG_fail;
28353 }
28354 {
28355 PyThreadState* __tstate = wxPyBeginAllowThreads();
28356 (arg1)->SetWindowStyleFlag(arg2);
28357
28358 wxPyEndAllowThreads(__tstate);
28359 if (PyErr_Occurred()) SWIG_fail;
28360 }
28361 Py_INCREF(Py_None); resultobj = Py_None;
28362 return resultobj;
28363 fail:
28364 return NULL;
28365 }
28366
28367
28368 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28369 PyObject *resultobj = NULL;
28370 wxWindow *arg1 = (wxWindow *) 0 ;
28371 long result;
28372 PyObject * obj0 = 0 ;
28373 char *kwnames[] = {
28374 (char *) "self", NULL
28375 };
28376
28377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28379 if (SWIG_arg_fail(1)) SWIG_fail;
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28383
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 {
28388 resultobj = SWIG_From_long(static_cast<long >(result));
28389 }
28390 return resultobj;
28391 fail:
28392 return NULL;
28393 }
28394
28395
28396 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28397 PyObject *resultobj = NULL;
28398 wxWindow *arg1 = (wxWindow *) 0 ;
28399 int arg2 ;
28400 bool result;
28401 PyObject * obj0 = 0 ;
28402 PyObject * obj1 = 0 ;
28403 char *kwnames[] = {
28404 (char *) "self",(char *) "flag", NULL
28405 };
28406
28407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28409 if (SWIG_arg_fail(1)) SWIG_fail;
28410 {
28411 arg2 = static_cast<int >(SWIG_As_int(obj1));
28412 if (SWIG_arg_fail(2)) SWIG_fail;
28413 }
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28417
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 {
28422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28423 }
28424 return resultobj;
28425 fail:
28426 return NULL;
28427 }
28428
28429
28430 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj = NULL;
28432 wxWindow *arg1 = (wxWindow *) 0 ;
28433 bool result;
28434 PyObject * obj0 = 0 ;
28435 char *kwnames[] = {
28436 (char *) "self", NULL
28437 };
28438
28439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28441 if (SWIG_arg_fail(1)) SWIG_fail;
28442 {
28443 PyThreadState* __tstate = wxPyBeginAllowThreads();
28444 result = (bool)((wxWindow const *)arg1)->IsRetained();
28445
28446 wxPyEndAllowThreads(__tstate);
28447 if (PyErr_Occurred()) SWIG_fail;
28448 }
28449 {
28450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28451 }
28452 return resultobj;
28453 fail:
28454 return NULL;
28455 }
28456
28457
28458 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28459 PyObject *resultobj = NULL;
28460 wxWindow *arg1 = (wxWindow *) 0 ;
28461 long arg2 ;
28462 PyObject * obj0 = 0 ;
28463 PyObject * obj1 = 0 ;
28464 char *kwnames[] = {
28465 (char *) "self",(char *) "exStyle", NULL
28466 };
28467
28468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28470 if (SWIG_arg_fail(1)) SWIG_fail;
28471 {
28472 arg2 = static_cast<long >(SWIG_As_long(obj1));
28473 if (SWIG_arg_fail(2)) SWIG_fail;
28474 }
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 (arg1)->SetExtraStyle(arg2);
28478
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 Py_INCREF(Py_None); resultobj = Py_None;
28483 return resultobj;
28484 fail:
28485 return NULL;
28486 }
28487
28488
28489 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28490 PyObject *resultobj = NULL;
28491 wxWindow *arg1 = (wxWindow *) 0 ;
28492 long result;
28493 PyObject * obj0 = 0 ;
28494 char *kwnames[] = {
28495 (char *) "self", NULL
28496 };
28497
28498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28500 if (SWIG_arg_fail(1)) SWIG_fail;
28501 {
28502 PyThreadState* __tstate = wxPyBeginAllowThreads();
28503 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28504
28505 wxPyEndAllowThreads(__tstate);
28506 if (PyErr_Occurred()) SWIG_fail;
28507 }
28508 {
28509 resultobj = SWIG_From_long(static_cast<long >(result));
28510 }
28511 return resultobj;
28512 fail:
28513 return NULL;
28514 }
28515
28516
28517 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28518 PyObject *resultobj = NULL;
28519 wxWindow *arg1 = (wxWindow *) 0 ;
28520 bool arg2 = (bool) true ;
28521 PyObject * obj0 = 0 ;
28522 PyObject * obj1 = 0 ;
28523 char *kwnames[] = {
28524 (char *) "self",(char *) "modal", NULL
28525 };
28526
28527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28529 if (SWIG_arg_fail(1)) SWIG_fail;
28530 if (obj1) {
28531 {
28532 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28533 if (SWIG_arg_fail(2)) SWIG_fail;
28534 }
28535 }
28536 {
28537 PyThreadState* __tstate = wxPyBeginAllowThreads();
28538 (arg1)->MakeModal(arg2);
28539
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 Py_INCREF(Py_None); resultobj = Py_None;
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28551 PyObject *resultobj = NULL;
28552 wxWindow *arg1 = (wxWindow *) 0 ;
28553 bool arg2 ;
28554 PyObject * obj0 = 0 ;
28555 PyObject * obj1 = 0 ;
28556 char *kwnames[] = {
28557 (char *) "self",(char *) "enableTheme", NULL
28558 };
28559
28560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28562 if (SWIG_arg_fail(1)) SWIG_fail;
28563 {
28564 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28565 if (SWIG_arg_fail(2)) SWIG_fail;
28566 }
28567 {
28568 PyThreadState* __tstate = wxPyBeginAllowThreads();
28569 (arg1)->SetThemeEnabled(arg2);
28570
28571 wxPyEndAllowThreads(__tstate);
28572 if (PyErr_Occurred()) SWIG_fail;
28573 }
28574 Py_INCREF(Py_None); resultobj = Py_None;
28575 return resultobj;
28576 fail:
28577 return NULL;
28578 }
28579
28580
28581 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28582 PyObject *resultobj = NULL;
28583 wxWindow *arg1 = (wxWindow *) 0 ;
28584 bool result;
28585 PyObject * obj0 = 0 ;
28586 char *kwnames[] = {
28587 (char *) "self", NULL
28588 };
28589
28590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28592 if (SWIG_arg_fail(1)) SWIG_fail;
28593 {
28594 PyThreadState* __tstate = wxPyBeginAllowThreads();
28595 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28596
28597 wxPyEndAllowThreads(__tstate);
28598 if (PyErr_Occurred()) SWIG_fail;
28599 }
28600 {
28601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28602 }
28603 return resultobj;
28604 fail:
28605 return NULL;
28606 }
28607
28608
28609 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28610 PyObject *resultobj = NULL;
28611 wxWindow *arg1 = (wxWindow *) 0 ;
28612 PyObject * obj0 = 0 ;
28613 char *kwnames[] = {
28614 (char *) "self", NULL
28615 };
28616
28617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",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 (arg1)->SetFocus();
28623
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 Py_INCREF(Py_None); resultobj = Py_None;
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj = NULL;
28636 wxWindow *arg1 = (wxWindow *) 0 ;
28637 PyObject * obj0 = 0 ;
28638 char *kwnames[] = {
28639 (char *) "self", NULL
28640 };
28641
28642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28644 if (SWIG_arg_fail(1)) SWIG_fail;
28645 {
28646 PyThreadState* __tstate = wxPyBeginAllowThreads();
28647 (arg1)->SetFocusFromKbd();
28648
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 Py_INCREF(Py_None); resultobj = Py_None;
28653 return resultobj;
28654 fail:
28655 return NULL;
28656 }
28657
28658
28659 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28660 PyObject *resultobj = NULL;
28661 wxWindow *result;
28662 char *kwnames[] = {
28663 NULL
28664 };
28665
28666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28667 {
28668 if (!wxPyCheckForApp()) SWIG_fail;
28669 PyThreadState* __tstate = wxPyBeginAllowThreads();
28670 result = (wxWindow *)wxWindow::FindFocus();
28671
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 {
28676 resultobj = wxPyMake_wxObject(result, 0);
28677 }
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28685 PyObject *resultobj = NULL;
28686 wxWindow *arg1 = (wxWindow *) 0 ;
28687 bool result;
28688 PyObject * obj0 = 0 ;
28689 char *kwnames[] = {
28690 (char *) "self", NULL
28691 };
28692
28693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28695 if (SWIG_arg_fail(1)) SWIG_fail;
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28699
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 {
28704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28705 }
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28713 PyObject *resultobj = NULL;
28714 wxWindow *arg1 = (wxWindow *) 0 ;
28715 bool result;
28716 PyObject * obj0 = 0 ;
28717 char *kwnames[] = {
28718 (char *) "self", NULL
28719 };
28720
28721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28723 if (SWIG_arg_fail(1)) SWIG_fail;
28724 {
28725 PyThreadState* __tstate = wxPyBeginAllowThreads();
28726 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28727
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 {
28732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28733 }
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28741 PyObject *resultobj = NULL;
28742 wxWindow *arg1 = (wxWindow *) 0 ;
28743 wxWindow *result;
28744 PyObject * obj0 = 0 ;
28745 char *kwnames[] = {
28746 (char *) "self", NULL
28747 };
28748
28749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28751 if (SWIG_arg_fail(1)) SWIG_fail;
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28755
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 {
28760 resultobj = wxPyMake_wxObject(result, 0);
28761 }
28762 return resultobj;
28763 fail:
28764 return NULL;
28765 }
28766
28767
28768 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28769 PyObject *resultobj = NULL;
28770 wxWindow *arg1 = (wxWindow *) 0 ;
28771 wxWindow *arg2 = (wxWindow *) 0 ;
28772 wxWindow *result;
28773 PyObject * obj0 = 0 ;
28774 PyObject * obj1 = 0 ;
28775 char *kwnames[] = {
28776 (char *) "self",(char *) "child", NULL
28777 };
28778
28779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28781 if (SWIG_arg_fail(1)) SWIG_fail;
28782 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28783 if (SWIG_arg_fail(2)) SWIG_fail;
28784 {
28785 PyThreadState* __tstate = wxPyBeginAllowThreads();
28786 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28787
28788 wxPyEndAllowThreads(__tstate);
28789 if (PyErr_Occurred()) SWIG_fail;
28790 }
28791 {
28792 resultobj = wxPyMake_wxObject(result, 0);
28793 }
28794 return resultobj;
28795 fail:
28796 return NULL;
28797 }
28798
28799
28800 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28801 PyObject *resultobj = NULL;
28802 wxWindow *arg1 = (wxWindow *) 0 ;
28803 wxWindow *arg2 = (wxWindow *) 0 ;
28804 PyObject * obj0 = 0 ;
28805 PyObject * obj1 = 0 ;
28806 char *kwnames[] = {
28807 (char *) "self",(char *) "win", NULL
28808 };
28809
28810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28812 if (SWIG_arg_fail(1)) SWIG_fail;
28813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(2)) SWIG_fail;
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 (arg1)->SetTmpDefaultItem(arg2);
28818
28819 wxPyEndAllowThreads(__tstate);
28820 if (PyErr_Occurred()) SWIG_fail;
28821 }
28822 Py_INCREF(Py_None); resultobj = Py_None;
28823 return resultobj;
28824 fail:
28825 return NULL;
28826 }
28827
28828
28829 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28830 PyObject *resultobj = NULL;
28831 wxWindow *arg1 = (wxWindow *) 0 ;
28832 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28833 bool result;
28834 PyObject * obj0 = 0 ;
28835 PyObject * obj1 = 0 ;
28836 char *kwnames[] = {
28837 (char *) "self",(char *) "flags", NULL
28838 };
28839
28840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28842 if (SWIG_arg_fail(1)) SWIG_fail;
28843 if (obj1) {
28844 {
28845 arg2 = static_cast<int >(SWIG_As_int(obj1));
28846 if (SWIG_arg_fail(2)) SWIG_fail;
28847 }
28848 }
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 result = (bool)(arg1)->Navigate(arg2);
28852
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 {
28857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28858 }
28859 return resultobj;
28860 fail:
28861 return NULL;
28862 }
28863
28864
28865 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28866 PyObject *resultobj = NULL;
28867 wxWindow *arg1 = (wxWindow *) 0 ;
28868 wxWindow *arg2 = (wxWindow *) 0 ;
28869 PyObject * obj0 = 0 ;
28870 PyObject * obj1 = 0 ;
28871 char *kwnames[] = {
28872 (char *) "self",(char *) "win", NULL
28873 };
28874
28875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28877 if (SWIG_arg_fail(1)) SWIG_fail;
28878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28879 if (SWIG_arg_fail(2)) SWIG_fail;
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 (arg1)->MoveAfterInTabOrder(arg2);
28883
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 Py_INCREF(Py_None); resultobj = Py_None;
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28895 PyObject *resultobj = NULL;
28896 wxWindow *arg1 = (wxWindow *) 0 ;
28897 wxWindow *arg2 = (wxWindow *) 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 char *kwnames[] = {
28901 (char *) "self",(char *) "win", NULL
28902 };
28903
28904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28906 if (SWIG_arg_fail(1)) SWIG_fail;
28907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28908 if (SWIG_arg_fail(2)) SWIG_fail;
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 (arg1)->MoveBeforeInTabOrder(arg2);
28912
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 Py_INCREF(Py_None); resultobj = Py_None;
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj = NULL;
28925 wxWindow *arg1 = (wxWindow *) 0 ;
28926 PyObject *result;
28927 PyObject * obj0 = 0 ;
28928 char *kwnames[] = {
28929 (char *) "self", NULL
28930 };
28931
28932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28934 if (SWIG_arg_fail(1)) SWIG_fail;
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 result = (PyObject *)wxWindow_GetChildren(arg1);
28938
28939 wxPyEndAllowThreads(__tstate);
28940 if (PyErr_Occurred()) SWIG_fail;
28941 }
28942 resultobj = result;
28943 return resultobj;
28944 fail:
28945 return NULL;
28946 }
28947
28948
28949 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28950 PyObject *resultobj = NULL;
28951 wxWindow *arg1 = (wxWindow *) 0 ;
28952 wxWindow *result;
28953 PyObject * obj0 = 0 ;
28954 char *kwnames[] = {
28955 (char *) "self", NULL
28956 };
28957
28958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28960 if (SWIG_arg_fail(1)) SWIG_fail;
28961 {
28962 PyThreadState* __tstate = wxPyBeginAllowThreads();
28963 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28964
28965 wxPyEndAllowThreads(__tstate);
28966 if (PyErr_Occurred()) SWIG_fail;
28967 }
28968 {
28969 resultobj = wxPyMake_wxObject(result, 0);
28970 }
28971 return resultobj;
28972 fail:
28973 return NULL;
28974 }
28975
28976
28977 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28978 PyObject *resultobj = NULL;
28979 wxWindow *arg1 = (wxWindow *) 0 ;
28980 wxWindow *result;
28981 PyObject * obj0 = 0 ;
28982 char *kwnames[] = {
28983 (char *) "self", NULL
28984 };
28985
28986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28988 if (SWIG_arg_fail(1)) SWIG_fail;
28989 {
28990 PyThreadState* __tstate = wxPyBeginAllowThreads();
28991 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28992
28993 wxPyEndAllowThreads(__tstate);
28994 if (PyErr_Occurred()) SWIG_fail;
28995 }
28996 {
28997 resultobj = wxPyMake_wxObject(result, 0);
28998 }
28999 return resultobj;
29000 fail:
29001 return NULL;
29002 }
29003
29004
29005 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
29006 PyObject *resultobj = NULL;
29007 wxWindow *arg1 = (wxWindow *) 0 ;
29008 bool result;
29009 PyObject * obj0 = 0 ;
29010 char *kwnames[] = {
29011 (char *) "self", NULL
29012 };
29013
29014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
29015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29016 if (SWIG_arg_fail(1)) SWIG_fail;
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
29020
29021 wxPyEndAllowThreads(__tstate);
29022 if (PyErr_Occurred()) SWIG_fail;
29023 }
29024 {
29025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29026 }
29027 return resultobj;
29028 fail:
29029 return NULL;
29030 }
29031
29032
29033 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29034 PyObject *resultobj = NULL;
29035 wxWindow *arg1 = (wxWindow *) 0 ;
29036 wxWindow *arg2 = (wxWindow *) 0 ;
29037 bool result;
29038 PyObject * obj0 = 0 ;
29039 PyObject * obj1 = 0 ;
29040 char *kwnames[] = {
29041 (char *) "self",(char *) "newParent", NULL
29042 };
29043
29044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29046 if (SWIG_arg_fail(1)) SWIG_fail;
29047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29048 if (SWIG_arg_fail(2)) SWIG_fail;
29049 {
29050 PyThreadState* __tstate = wxPyBeginAllowThreads();
29051 result = (bool)(arg1)->Reparent(arg2);
29052
29053 wxPyEndAllowThreads(__tstate);
29054 if (PyErr_Occurred()) SWIG_fail;
29055 }
29056 {
29057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29058 }
29059 return resultobj;
29060 fail:
29061 return NULL;
29062 }
29063
29064
29065 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29066 PyObject *resultobj = NULL;
29067 wxWindow *arg1 = (wxWindow *) 0 ;
29068 wxWindow *arg2 = (wxWindow *) 0 ;
29069 PyObject * obj0 = 0 ;
29070 PyObject * obj1 = 0 ;
29071 char *kwnames[] = {
29072 (char *) "self",(char *) "child", NULL
29073 };
29074
29075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29077 if (SWIG_arg_fail(1)) SWIG_fail;
29078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29079 if (SWIG_arg_fail(2)) SWIG_fail;
29080 {
29081 PyThreadState* __tstate = wxPyBeginAllowThreads();
29082 (arg1)->AddChild(arg2);
29083
29084 wxPyEndAllowThreads(__tstate);
29085 if (PyErr_Occurred()) SWIG_fail;
29086 }
29087 Py_INCREF(Py_None); resultobj = Py_None;
29088 return resultobj;
29089 fail:
29090 return NULL;
29091 }
29092
29093
29094 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29095 PyObject *resultobj = NULL;
29096 wxWindow *arg1 = (wxWindow *) 0 ;
29097 wxWindow *arg2 = (wxWindow *) 0 ;
29098 PyObject * obj0 = 0 ;
29099 PyObject * obj1 = 0 ;
29100 char *kwnames[] = {
29101 (char *) "self",(char *) "child", NULL
29102 };
29103
29104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29106 if (SWIG_arg_fail(1)) SWIG_fail;
29107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(2)) SWIG_fail;
29109 {
29110 PyThreadState* __tstate = wxPyBeginAllowThreads();
29111 (arg1)->RemoveChild(arg2);
29112
29113 wxPyEndAllowThreads(__tstate);
29114 if (PyErr_Occurred()) SWIG_fail;
29115 }
29116 Py_INCREF(Py_None); resultobj = Py_None;
29117 return resultobj;
29118 fail:
29119 return NULL;
29120 }
29121
29122
29123 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29124 PyObject *resultobj = NULL;
29125 wxWindow *arg1 = (wxWindow *) 0 ;
29126 long arg2 ;
29127 wxWindow *result;
29128 PyObject * obj0 = 0 ;
29129 PyObject * obj1 = 0 ;
29130 char *kwnames[] = {
29131 (char *) "self",(char *) "winid", NULL
29132 };
29133
29134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29136 if (SWIG_arg_fail(1)) SWIG_fail;
29137 {
29138 arg2 = static_cast<long >(SWIG_As_long(obj1));
29139 if (SWIG_arg_fail(2)) SWIG_fail;
29140 }
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 result = (wxWindow *)(arg1)->FindWindow(arg2);
29144
29145 wxPyEndAllowThreads(__tstate);
29146 if (PyErr_Occurred()) SWIG_fail;
29147 }
29148 {
29149 resultobj = wxPyMake_wxObject(result, 0);
29150 }
29151 return resultobj;
29152 fail:
29153 return NULL;
29154 }
29155
29156
29157 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29158 PyObject *resultobj = NULL;
29159 wxWindow *arg1 = (wxWindow *) 0 ;
29160 wxString *arg2 = 0 ;
29161 wxWindow *result;
29162 bool temp2 = false ;
29163 PyObject * obj0 = 0 ;
29164 PyObject * obj1 = 0 ;
29165 char *kwnames[] = {
29166 (char *) "self",(char *) "name", NULL
29167 };
29168
29169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29171 if (SWIG_arg_fail(1)) SWIG_fail;
29172 {
29173 arg2 = wxString_in_helper(obj1);
29174 if (arg2 == NULL) SWIG_fail;
29175 temp2 = true;
29176 }
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29180
29181 wxPyEndAllowThreads(__tstate);
29182 if (PyErr_Occurred()) SWIG_fail;
29183 }
29184 {
29185 resultobj = wxPyMake_wxObject(result, 0);
29186 }
29187 {
29188 if (temp2)
29189 delete arg2;
29190 }
29191 return resultobj;
29192 fail:
29193 {
29194 if (temp2)
29195 delete arg2;
29196 }
29197 return NULL;
29198 }
29199
29200
29201 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29202 PyObject *resultobj = NULL;
29203 wxWindow *arg1 = (wxWindow *) 0 ;
29204 wxEvtHandler *result;
29205 PyObject * obj0 = 0 ;
29206 char *kwnames[] = {
29207 (char *) "self", NULL
29208 };
29209
29210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29212 if (SWIG_arg_fail(1)) SWIG_fail;
29213 {
29214 PyThreadState* __tstate = wxPyBeginAllowThreads();
29215 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29216
29217 wxPyEndAllowThreads(__tstate);
29218 if (PyErr_Occurred()) SWIG_fail;
29219 }
29220 {
29221 resultobj = wxPyMake_wxObject(result, 0);
29222 }
29223 return resultobj;
29224 fail:
29225 return NULL;
29226 }
29227
29228
29229 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29230 PyObject *resultobj = NULL;
29231 wxWindow *arg1 = (wxWindow *) 0 ;
29232 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29233 PyObject * obj0 = 0 ;
29234 PyObject * obj1 = 0 ;
29235 char *kwnames[] = {
29236 (char *) "self",(char *) "handler", NULL
29237 };
29238
29239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29241 if (SWIG_arg_fail(1)) SWIG_fail;
29242 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29243 if (SWIG_arg_fail(2)) SWIG_fail;
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 (arg1)->SetEventHandler(arg2);
29247
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 Py_INCREF(Py_None); resultobj = Py_None;
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29259 PyObject *resultobj = NULL;
29260 wxWindow *arg1 = (wxWindow *) 0 ;
29261 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29262 PyObject * obj0 = 0 ;
29263 PyObject * obj1 = 0 ;
29264 char *kwnames[] = {
29265 (char *) "self",(char *) "handler", NULL
29266 };
29267
29268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29270 if (SWIG_arg_fail(1)) SWIG_fail;
29271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29272 if (SWIG_arg_fail(2)) SWIG_fail;
29273 {
29274 PyThreadState* __tstate = wxPyBeginAllowThreads();
29275 (arg1)->PushEventHandler(arg2);
29276
29277 wxPyEndAllowThreads(__tstate);
29278 if (PyErr_Occurred()) SWIG_fail;
29279 }
29280 Py_INCREF(Py_None); resultobj = Py_None;
29281 return resultobj;
29282 fail:
29283 return NULL;
29284 }
29285
29286
29287 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29288 PyObject *resultobj = NULL;
29289 wxWindow *arg1 = (wxWindow *) 0 ;
29290 bool arg2 = (bool) false ;
29291 wxEvtHandler *result;
29292 PyObject * obj0 = 0 ;
29293 PyObject * obj1 = 0 ;
29294 char *kwnames[] = {
29295 (char *) "self",(char *) "deleteHandler", NULL
29296 };
29297
29298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29300 if (SWIG_arg_fail(1)) SWIG_fail;
29301 if (obj1) {
29302 {
29303 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29304 if (SWIG_arg_fail(2)) SWIG_fail;
29305 }
29306 }
29307 {
29308 PyThreadState* __tstate = wxPyBeginAllowThreads();
29309 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29310
29311 wxPyEndAllowThreads(__tstate);
29312 if (PyErr_Occurred()) SWIG_fail;
29313 }
29314 {
29315 resultobj = wxPyMake_wxObject(result, 0);
29316 }
29317 return resultobj;
29318 fail:
29319 return NULL;
29320 }
29321
29322
29323 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29324 PyObject *resultobj = NULL;
29325 wxWindow *arg1 = (wxWindow *) 0 ;
29326 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29327 bool result;
29328 PyObject * obj0 = 0 ;
29329 PyObject * obj1 = 0 ;
29330 char *kwnames[] = {
29331 (char *) "self",(char *) "handler", NULL
29332 };
29333
29334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29336 if (SWIG_arg_fail(1)) SWIG_fail;
29337 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29338 if (SWIG_arg_fail(2)) SWIG_fail;
29339 {
29340 PyThreadState* __tstate = wxPyBeginAllowThreads();
29341 result = (bool)(arg1)->RemoveEventHandler(arg2);
29342
29343 wxPyEndAllowThreads(__tstate);
29344 if (PyErr_Occurred()) SWIG_fail;
29345 }
29346 {
29347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29348 }
29349 return resultobj;
29350 fail:
29351 return NULL;
29352 }
29353
29354
29355 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29356 PyObject *resultobj = NULL;
29357 wxWindow *arg1 = (wxWindow *) 0 ;
29358 wxValidator *arg2 = 0 ;
29359 PyObject * obj0 = 0 ;
29360 PyObject * obj1 = 0 ;
29361 char *kwnames[] = {
29362 (char *) "self",(char *) "validator", NULL
29363 };
29364
29365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29367 if (SWIG_arg_fail(1)) SWIG_fail;
29368 {
29369 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29370 if (SWIG_arg_fail(2)) SWIG_fail;
29371 if (arg2 == NULL) {
29372 SWIG_null_ref("wxValidator");
29373 }
29374 if (SWIG_arg_fail(2)) SWIG_fail;
29375 }
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 (arg1)->SetValidator((wxValidator const &)*arg2);
29379
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 Py_INCREF(Py_None); resultobj = Py_None;
29384 return resultobj;
29385 fail:
29386 return NULL;
29387 }
29388
29389
29390 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29391 PyObject *resultobj = NULL;
29392 wxWindow *arg1 = (wxWindow *) 0 ;
29393 wxValidator *result;
29394 PyObject * obj0 = 0 ;
29395 char *kwnames[] = {
29396 (char *) "self", NULL
29397 };
29398
29399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29401 if (SWIG_arg_fail(1)) SWIG_fail;
29402 {
29403 PyThreadState* __tstate = wxPyBeginAllowThreads();
29404 result = (wxValidator *)(arg1)->GetValidator();
29405
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 {
29410 resultobj = wxPyMake_wxObject(result, (bool)0);
29411 }
29412 return resultobj;
29413 fail:
29414 return NULL;
29415 }
29416
29417
29418 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29419 PyObject *resultobj = NULL;
29420 wxWindow *arg1 = (wxWindow *) 0 ;
29421 bool result;
29422 PyObject * obj0 = 0 ;
29423 char *kwnames[] = {
29424 (char *) "self", NULL
29425 };
29426
29427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29429 if (SWIG_arg_fail(1)) SWIG_fail;
29430 {
29431 PyThreadState* __tstate = wxPyBeginAllowThreads();
29432 result = (bool)(arg1)->Validate();
29433
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 {
29438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29439 }
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = NULL;
29448 wxWindow *arg1 = (wxWindow *) 0 ;
29449 bool result;
29450 PyObject * obj0 = 0 ;
29451 char *kwnames[] = {
29452 (char *) "self", NULL
29453 };
29454
29455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29457 if (SWIG_arg_fail(1)) SWIG_fail;
29458 {
29459 PyThreadState* __tstate = wxPyBeginAllowThreads();
29460 result = (bool)(arg1)->TransferDataToWindow();
29461
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 {
29466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29467 }
29468 return resultobj;
29469 fail:
29470 return NULL;
29471 }
29472
29473
29474 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj = NULL;
29476 wxWindow *arg1 = (wxWindow *) 0 ;
29477 bool result;
29478 PyObject * obj0 = 0 ;
29479 char *kwnames[] = {
29480 (char *) "self", NULL
29481 };
29482
29483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29485 if (SWIG_arg_fail(1)) SWIG_fail;
29486 {
29487 PyThreadState* __tstate = wxPyBeginAllowThreads();
29488 result = (bool)(arg1)->TransferDataFromWindow();
29489
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 {
29494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29495 }
29496 return resultobj;
29497 fail:
29498 return NULL;
29499 }
29500
29501
29502 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29503 PyObject *resultobj = NULL;
29504 wxWindow *arg1 = (wxWindow *) 0 ;
29505 PyObject * obj0 = 0 ;
29506 char *kwnames[] = {
29507 (char *) "self", NULL
29508 };
29509
29510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",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 (arg1)->InitDialog();
29516
29517 wxPyEndAllowThreads(__tstate);
29518 if (PyErr_Occurred()) SWIG_fail;
29519 }
29520 Py_INCREF(Py_None); resultobj = Py_None;
29521 return resultobj;
29522 fail:
29523 return NULL;
29524 }
29525
29526
29527 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29528 PyObject *resultobj = NULL;
29529 wxWindow *arg1 = (wxWindow *) 0 ;
29530 wxAcceleratorTable *arg2 = 0 ;
29531 PyObject * obj0 = 0 ;
29532 PyObject * obj1 = 0 ;
29533 char *kwnames[] = {
29534 (char *) "self",(char *) "accel", NULL
29535 };
29536
29537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29542 if (SWIG_arg_fail(2)) SWIG_fail;
29543 if (arg2 == NULL) {
29544 SWIG_null_ref("wxAcceleratorTable");
29545 }
29546 if (SWIG_arg_fail(2)) SWIG_fail;
29547 }
29548 {
29549 PyThreadState* __tstate = wxPyBeginAllowThreads();
29550 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29551
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 Py_INCREF(Py_None); resultobj = Py_None;
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29563 PyObject *resultobj = NULL;
29564 wxWindow *arg1 = (wxWindow *) 0 ;
29565 wxAcceleratorTable *result;
29566 PyObject * obj0 = 0 ;
29567 char *kwnames[] = {
29568 (char *) "self", NULL
29569 };
29570
29571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29573 if (SWIG_arg_fail(1)) SWIG_fail;
29574 {
29575 PyThreadState* __tstate = wxPyBeginAllowThreads();
29576 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29577
29578 wxPyEndAllowThreads(__tstate);
29579 if (PyErr_Occurred()) SWIG_fail;
29580 }
29581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29582 return resultobj;
29583 fail:
29584 return NULL;
29585 }
29586
29587
29588 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj = NULL;
29590 wxWindow *arg1 = (wxWindow *) 0 ;
29591 int arg2 ;
29592 int arg3 ;
29593 int arg4 ;
29594 bool result;
29595 PyObject * obj0 = 0 ;
29596 PyObject * obj1 = 0 ;
29597 PyObject * obj2 = 0 ;
29598 PyObject * obj3 = 0 ;
29599 char *kwnames[] = {
29600 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29601 };
29602
29603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29605 if (SWIG_arg_fail(1)) SWIG_fail;
29606 {
29607 arg2 = static_cast<int >(SWIG_As_int(obj1));
29608 if (SWIG_arg_fail(2)) SWIG_fail;
29609 }
29610 {
29611 arg3 = static_cast<int >(SWIG_As_int(obj2));
29612 if (SWIG_arg_fail(3)) SWIG_fail;
29613 }
29614 {
29615 arg4 = static_cast<int >(SWIG_As_int(obj3));
29616 if (SWIG_arg_fail(4)) SWIG_fail;
29617 }
29618 {
29619 PyThreadState* __tstate = wxPyBeginAllowThreads();
29620 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29621
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 {
29626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29627 }
29628 return resultobj;
29629 fail:
29630 return NULL;
29631 }
29632
29633
29634 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29635 PyObject *resultobj = NULL;
29636 wxWindow *arg1 = (wxWindow *) 0 ;
29637 int arg2 ;
29638 bool result;
29639 PyObject * obj0 = 0 ;
29640 PyObject * obj1 = 0 ;
29641 char *kwnames[] = {
29642 (char *) "self",(char *) "hotkeyId", NULL
29643 };
29644
29645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29647 if (SWIG_arg_fail(1)) SWIG_fail;
29648 {
29649 arg2 = static_cast<int >(SWIG_As_int(obj1));
29650 if (SWIG_arg_fail(2)) SWIG_fail;
29651 }
29652 {
29653 PyThreadState* __tstate = wxPyBeginAllowThreads();
29654 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29655
29656 wxPyEndAllowThreads(__tstate);
29657 if (PyErr_Occurred()) SWIG_fail;
29658 }
29659 {
29660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29661 }
29662 return resultobj;
29663 fail:
29664 return NULL;
29665 }
29666
29667
29668 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29669 PyObject *resultobj = NULL;
29670 wxWindow *arg1 = (wxWindow *) 0 ;
29671 wxPoint *arg2 = 0 ;
29672 wxPoint result;
29673 wxPoint temp2 ;
29674 PyObject * obj0 = 0 ;
29675 PyObject * obj1 = 0 ;
29676 char *kwnames[] = {
29677 (char *) "self",(char *) "pt", NULL
29678 };
29679
29680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29682 if (SWIG_arg_fail(1)) SWIG_fail;
29683 {
29684 arg2 = &temp2;
29685 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29686 }
29687 {
29688 PyThreadState* __tstate = wxPyBeginAllowThreads();
29689 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29690
29691 wxPyEndAllowThreads(__tstate);
29692 if (PyErr_Occurred()) SWIG_fail;
29693 }
29694 {
29695 wxPoint * resultptr;
29696 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29697 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29698 }
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29706 PyObject *resultobj = NULL;
29707 wxWindow *arg1 = (wxWindow *) 0 ;
29708 wxSize *arg2 = 0 ;
29709 wxSize result;
29710 wxSize temp2 ;
29711 PyObject * obj0 = 0 ;
29712 PyObject * obj1 = 0 ;
29713 char *kwnames[] = {
29714 (char *) "self",(char *) "sz", NULL
29715 };
29716
29717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29719 if (SWIG_arg_fail(1)) SWIG_fail;
29720 {
29721 arg2 = &temp2;
29722 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29723 }
29724 {
29725 PyThreadState* __tstate = wxPyBeginAllowThreads();
29726 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29727
29728 wxPyEndAllowThreads(__tstate);
29729 if (PyErr_Occurred()) SWIG_fail;
29730 }
29731 {
29732 wxSize * resultptr;
29733 resultptr = new wxSize(static_cast<wxSize & >(result));
29734 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29735 }
29736 return resultobj;
29737 fail:
29738 return NULL;
29739 }
29740
29741
29742 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29743 PyObject *resultobj = NULL;
29744 wxWindow *arg1 = (wxWindow *) 0 ;
29745 wxPoint *arg2 = 0 ;
29746 wxPoint result;
29747 wxPoint temp2 ;
29748 PyObject * obj0 = 0 ;
29749 PyObject * obj1 = 0 ;
29750 char *kwnames[] = {
29751 (char *) "self",(char *) "pt", NULL
29752 };
29753
29754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29756 if (SWIG_arg_fail(1)) SWIG_fail;
29757 {
29758 arg2 = &temp2;
29759 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29760 }
29761 {
29762 PyThreadState* __tstate = wxPyBeginAllowThreads();
29763 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29764
29765 wxPyEndAllowThreads(__tstate);
29766 if (PyErr_Occurred()) SWIG_fail;
29767 }
29768 {
29769 wxPoint * resultptr;
29770 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29772 }
29773 return resultobj;
29774 fail:
29775 return NULL;
29776 }
29777
29778
29779 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29780 PyObject *resultobj = NULL;
29781 wxWindow *arg1 = (wxWindow *) 0 ;
29782 wxSize *arg2 = 0 ;
29783 wxSize result;
29784 wxSize temp2 ;
29785 PyObject * obj0 = 0 ;
29786 PyObject * obj1 = 0 ;
29787 char *kwnames[] = {
29788 (char *) "self",(char *) "sz", NULL
29789 };
29790
29791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29793 if (SWIG_arg_fail(1)) SWIG_fail;
29794 {
29795 arg2 = &temp2;
29796 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29797 }
29798 {
29799 PyThreadState* __tstate = wxPyBeginAllowThreads();
29800 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29801
29802 wxPyEndAllowThreads(__tstate);
29803 if (PyErr_Occurred()) SWIG_fail;
29804 }
29805 {
29806 wxSize * resultptr;
29807 resultptr = new wxSize(static_cast<wxSize & >(result));
29808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29809 }
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29817 PyObject *resultobj = NULL;
29818 wxWindow *arg1 = (wxWindow *) 0 ;
29819 wxPoint *arg2 = 0 ;
29820 wxPoint result;
29821 wxPoint temp2 ;
29822 PyObject * obj0 = 0 ;
29823 PyObject * obj1 = 0 ;
29824 char *kwnames[] = {
29825 (char *) "self",(char *) "pt", NULL
29826 };
29827
29828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29830 if (SWIG_arg_fail(1)) SWIG_fail;
29831 {
29832 arg2 = &temp2;
29833 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29834 }
29835 {
29836 PyThreadState* __tstate = wxPyBeginAllowThreads();
29837 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29838
29839 wxPyEndAllowThreads(__tstate);
29840 if (PyErr_Occurred()) SWIG_fail;
29841 }
29842 {
29843 wxPoint * resultptr;
29844 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29845 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29846 }
29847 return resultobj;
29848 fail:
29849 return NULL;
29850 }
29851
29852
29853 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29854 PyObject *resultobj = NULL;
29855 wxWindow *arg1 = (wxWindow *) 0 ;
29856 wxSize *arg2 = 0 ;
29857 wxSize result;
29858 wxSize temp2 ;
29859 PyObject * obj0 = 0 ;
29860 PyObject * obj1 = 0 ;
29861 char *kwnames[] = {
29862 (char *) "self",(char *) "sz", NULL
29863 };
29864
29865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29867 if (SWIG_arg_fail(1)) SWIG_fail;
29868 {
29869 arg2 = &temp2;
29870 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29871 }
29872 {
29873 PyThreadState* __tstate = wxPyBeginAllowThreads();
29874 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29875
29876 wxPyEndAllowThreads(__tstate);
29877 if (PyErr_Occurred()) SWIG_fail;
29878 }
29879 {
29880 wxSize * resultptr;
29881 resultptr = new wxSize(static_cast<wxSize & >(result));
29882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29883 }
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29891 PyObject *resultobj = NULL;
29892 wxWindow *arg1 = (wxWindow *) 0 ;
29893 int arg2 ;
29894 int arg3 ;
29895 PyObject * obj0 = 0 ;
29896 PyObject * obj1 = 0 ;
29897 PyObject * obj2 = 0 ;
29898 char *kwnames[] = {
29899 (char *) "self",(char *) "x",(char *) "y", NULL
29900 };
29901
29902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29904 if (SWIG_arg_fail(1)) SWIG_fail;
29905 {
29906 arg2 = static_cast<int >(SWIG_As_int(obj1));
29907 if (SWIG_arg_fail(2)) SWIG_fail;
29908 }
29909 {
29910 arg3 = static_cast<int >(SWIG_As_int(obj2));
29911 if (SWIG_arg_fail(3)) SWIG_fail;
29912 }
29913 {
29914 PyThreadState* __tstate = wxPyBeginAllowThreads();
29915 (arg1)->WarpPointer(arg2,arg3);
29916
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 Py_INCREF(Py_None); resultobj = Py_None;
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29928 PyObject *resultobj = NULL;
29929 wxWindow *arg1 = (wxWindow *) 0 ;
29930 PyObject * obj0 = 0 ;
29931 char *kwnames[] = {
29932 (char *) "self", NULL
29933 };
29934
29935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29937 if (SWIG_arg_fail(1)) SWIG_fail;
29938 {
29939 PyThreadState* __tstate = wxPyBeginAllowThreads();
29940 (arg1)->CaptureMouse();
29941
29942 wxPyEndAllowThreads(__tstate);
29943 if (PyErr_Occurred()) SWIG_fail;
29944 }
29945 Py_INCREF(Py_None); resultobj = Py_None;
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj = NULL;
29954 wxWindow *arg1 = (wxWindow *) 0 ;
29955 PyObject * obj0 = 0 ;
29956 char *kwnames[] = {
29957 (char *) "self", NULL
29958 };
29959
29960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29962 if (SWIG_arg_fail(1)) SWIG_fail;
29963 {
29964 PyThreadState* __tstate = wxPyBeginAllowThreads();
29965 (arg1)->ReleaseMouse();
29966
29967 wxPyEndAllowThreads(__tstate);
29968 if (PyErr_Occurred()) SWIG_fail;
29969 }
29970 Py_INCREF(Py_None); resultobj = Py_None;
29971 return resultobj;
29972 fail:
29973 return NULL;
29974 }
29975
29976
29977 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29978 PyObject *resultobj = NULL;
29979 wxWindow *result;
29980 char *kwnames[] = {
29981 NULL
29982 };
29983
29984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29985 {
29986 if (!wxPyCheckForApp()) SWIG_fail;
29987 PyThreadState* __tstate = wxPyBeginAllowThreads();
29988 result = (wxWindow *)wxWindow::GetCapture();
29989
29990 wxPyEndAllowThreads(__tstate);
29991 if (PyErr_Occurred()) SWIG_fail;
29992 }
29993 {
29994 resultobj = wxPyMake_wxObject(result, 0);
29995 }
29996 return resultobj;
29997 fail:
29998 return NULL;
29999 }
30000
30001
30002 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
30003 PyObject *resultobj = NULL;
30004 wxWindow *arg1 = (wxWindow *) 0 ;
30005 bool result;
30006 PyObject * obj0 = 0 ;
30007 char *kwnames[] = {
30008 (char *) "self", NULL
30009 };
30010
30011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
30012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30013 if (SWIG_arg_fail(1)) SWIG_fail;
30014 {
30015 PyThreadState* __tstate = wxPyBeginAllowThreads();
30016 result = (bool)((wxWindow const *)arg1)->HasCapture();
30017
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 {
30022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30023 }
30024 return resultobj;
30025 fail:
30026 return NULL;
30027 }
30028
30029
30030 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30031 PyObject *resultobj = NULL;
30032 wxWindow *arg1 = (wxWindow *) 0 ;
30033 bool arg2 = (bool) true ;
30034 wxRect *arg3 = (wxRect *) NULL ;
30035 PyObject * obj0 = 0 ;
30036 PyObject * obj1 = 0 ;
30037 PyObject * obj2 = 0 ;
30038 char *kwnames[] = {
30039 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30040 };
30041
30042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30044 if (SWIG_arg_fail(1)) SWIG_fail;
30045 if (obj1) {
30046 {
30047 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30048 if (SWIG_arg_fail(2)) SWIG_fail;
30049 }
30050 }
30051 if (obj2) {
30052 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30053 if (SWIG_arg_fail(3)) SWIG_fail;
30054 }
30055 {
30056 PyThreadState* __tstate = wxPyBeginAllowThreads();
30057 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30058
30059 wxPyEndAllowThreads(__tstate);
30060 if (PyErr_Occurred()) SWIG_fail;
30061 }
30062 Py_INCREF(Py_None); resultobj = Py_None;
30063 return resultobj;
30064 fail:
30065 return NULL;
30066 }
30067
30068
30069 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30070 PyObject *resultobj = NULL;
30071 wxWindow *arg1 = (wxWindow *) 0 ;
30072 wxRect *arg2 = 0 ;
30073 bool arg3 = (bool) true ;
30074 wxRect temp2 ;
30075 PyObject * obj0 = 0 ;
30076 PyObject * obj1 = 0 ;
30077 PyObject * obj2 = 0 ;
30078 char *kwnames[] = {
30079 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30080 };
30081
30082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30084 if (SWIG_arg_fail(1)) SWIG_fail;
30085 {
30086 arg2 = &temp2;
30087 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30088 }
30089 if (obj2) {
30090 {
30091 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30092 if (SWIG_arg_fail(3)) SWIG_fail;
30093 }
30094 }
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30098
30099 wxPyEndAllowThreads(__tstate);
30100 if (PyErr_Occurred()) SWIG_fail;
30101 }
30102 Py_INCREF(Py_None); resultobj = Py_None;
30103 return resultobj;
30104 fail:
30105 return NULL;
30106 }
30107
30108
30109 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30110 PyObject *resultobj = NULL;
30111 wxWindow *arg1 = (wxWindow *) 0 ;
30112 PyObject * obj0 = 0 ;
30113 char *kwnames[] = {
30114 (char *) "self", NULL
30115 };
30116
30117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30119 if (SWIG_arg_fail(1)) SWIG_fail;
30120 {
30121 PyThreadState* __tstate = wxPyBeginAllowThreads();
30122 (arg1)->Update();
30123
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 Py_INCREF(Py_None); resultobj = Py_None;
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj = NULL;
30136 wxWindow *arg1 = (wxWindow *) 0 ;
30137 PyObject * obj0 = 0 ;
30138 char *kwnames[] = {
30139 (char *) "self", NULL
30140 };
30141
30142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30144 if (SWIG_arg_fail(1)) SWIG_fail;
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 (arg1)->ClearBackground();
30148
30149 wxPyEndAllowThreads(__tstate);
30150 if (PyErr_Occurred()) SWIG_fail;
30151 }
30152 Py_INCREF(Py_None); resultobj = Py_None;
30153 return resultobj;
30154 fail:
30155 return NULL;
30156 }
30157
30158
30159 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30160 PyObject *resultobj = NULL;
30161 wxWindow *arg1 = (wxWindow *) 0 ;
30162 PyObject * obj0 = 0 ;
30163 char *kwnames[] = {
30164 (char *) "self", NULL
30165 };
30166
30167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30169 if (SWIG_arg_fail(1)) SWIG_fail;
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 (arg1)->Freeze();
30173
30174 wxPyEndAllowThreads(__tstate);
30175 if (PyErr_Occurred()) SWIG_fail;
30176 }
30177 Py_INCREF(Py_None); resultobj = Py_None;
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30185 PyObject *resultobj = NULL;
30186 wxWindow *arg1 = (wxWindow *) 0 ;
30187 PyObject * obj0 = 0 ;
30188 char *kwnames[] = {
30189 (char *) "self", NULL
30190 };
30191
30192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30194 if (SWIG_arg_fail(1)) SWIG_fail;
30195 {
30196 PyThreadState* __tstate = wxPyBeginAllowThreads();
30197 (arg1)->Thaw();
30198
30199 wxPyEndAllowThreads(__tstate);
30200 if (PyErr_Occurred()) SWIG_fail;
30201 }
30202 Py_INCREF(Py_None); resultobj = Py_None;
30203 return resultobj;
30204 fail:
30205 return NULL;
30206 }
30207
30208
30209 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30210 PyObject *resultobj = NULL;
30211 wxWindow *arg1 = (wxWindow *) 0 ;
30212 wxDC *arg2 = 0 ;
30213 PyObject * obj0 = 0 ;
30214 PyObject * obj1 = 0 ;
30215 char *kwnames[] = {
30216 (char *) "self",(char *) "dc", NULL
30217 };
30218
30219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30224 if (SWIG_arg_fail(2)) SWIG_fail;
30225 if (arg2 == NULL) {
30226 SWIG_null_ref("wxDC");
30227 }
30228 if (SWIG_arg_fail(2)) SWIG_fail;
30229 }
30230 {
30231 PyThreadState* __tstate = wxPyBeginAllowThreads();
30232 (arg1)->PrepareDC(*arg2);
30233
30234 wxPyEndAllowThreads(__tstate);
30235 if (PyErr_Occurred()) SWIG_fail;
30236 }
30237 Py_INCREF(Py_None); resultobj = Py_None;
30238 return resultobj;
30239 fail:
30240 return NULL;
30241 }
30242
30243
30244 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30245 PyObject *resultobj = NULL;
30246 wxWindow *arg1 = (wxWindow *) 0 ;
30247 wxRegion *result;
30248 PyObject * obj0 = 0 ;
30249 char *kwnames[] = {
30250 (char *) "self", NULL
30251 };
30252
30253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30255 if (SWIG_arg_fail(1)) SWIG_fail;
30256 {
30257 PyThreadState* __tstate = wxPyBeginAllowThreads();
30258 {
30259 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30260 result = (wxRegion *) &_result_ref;
30261 }
30262
30263 wxPyEndAllowThreads(__tstate);
30264 if (PyErr_Occurred()) SWIG_fail;
30265 }
30266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30267 return resultobj;
30268 fail:
30269 return NULL;
30270 }
30271
30272
30273 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30274 PyObject *resultobj = NULL;
30275 wxWindow *arg1 = (wxWindow *) 0 ;
30276 wxRect result;
30277 PyObject * obj0 = 0 ;
30278 char *kwnames[] = {
30279 (char *) "self", NULL
30280 };
30281
30282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30284 if (SWIG_arg_fail(1)) SWIG_fail;
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30288
30289 wxPyEndAllowThreads(__tstate);
30290 if (PyErr_Occurred()) SWIG_fail;
30291 }
30292 {
30293 wxRect * resultptr;
30294 resultptr = new wxRect(static_cast<wxRect & >(result));
30295 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30296 }
30297 return resultobj;
30298 fail:
30299 return NULL;
30300 }
30301
30302
30303 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30304 PyObject *resultobj = NULL;
30305 wxWindow *arg1 = (wxWindow *) 0 ;
30306 int arg2 ;
30307 int arg3 ;
30308 int arg4 = (int) 1 ;
30309 int arg5 = (int) 1 ;
30310 bool result;
30311 PyObject * obj0 = 0 ;
30312 PyObject * obj1 = 0 ;
30313 PyObject * obj2 = 0 ;
30314 PyObject * obj3 = 0 ;
30315 PyObject * obj4 = 0 ;
30316 char *kwnames[] = {
30317 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30318 };
30319
30320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30322 if (SWIG_arg_fail(1)) SWIG_fail;
30323 {
30324 arg2 = static_cast<int >(SWIG_As_int(obj1));
30325 if (SWIG_arg_fail(2)) SWIG_fail;
30326 }
30327 {
30328 arg3 = static_cast<int >(SWIG_As_int(obj2));
30329 if (SWIG_arg_fail(3)) SWIG_fail;
30330 }
30331 if (obj3) {
30332 {
30333 arg4 = static_cast<int >(SWIG_As_int(obj3));
30334 if (SWIG_arg_fail(4)) SWIG_fail;
30335 }
30336 }
30337 if (obj4) {
30338 {
30339 arg5 = static_cast<int >(SWIG_As_int(obj4));
30340 if (SWIG_arg_fail(5)) SWIG_fail;
30341 }
30342 }
30343 {
30344 PyThreadState* __tstate = wxPyBeginAllowThreads();
30345 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30346
30347 wxPyEndAllowThreads(__tstate);
30348 if (PyErr_Occurred()) SWIG_fail;
30349 }
30350 {
30351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30352 }
30353 return resultobj;
30354 fail:
30355 return NULL;
30356 }
30357
30358
30359 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30360 PyObject *resultobj = NULL;
30361 wxWindow *arg1 = (wxWindow *) 0 ;
30362 wxPoint *arg2 = 0 ;
30363 bool result;
30364 wxPoint temp2 ;
30365 PyObject * obj0 = 0 ;
30366 PyObject * obj1 = 0 ;
30367 char *kwnames[] = {
30368 (char *) "self",(char *) "pt", NULL
30369 };
30370
30371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30373 if (SWIG_arg_fail(1)) SWIG_fail;
30374 {
30375 arg2 = &temp2;
30376 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30377 }
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30381
30382 wxPyEndAllowThreads(__tstate);
30383 if (PyErr_Occurred()) SWIG_fail;
30384 }
30385 {
30386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30387 }
30388 return resultobj;
30389 fail:
30390 return NULL;
30391 }
30392
30393
30394 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30395 PyObject *resultobj = NULL;
30396 wxWindow *arg1 = (wxWindow *) 0 ;
30397 wxRect *arg2 = 0 ;
30398 bool result;
30399 wxRect temp2 ;
30400 PyObject * obj0 = 0 ;
30401 PyObject * obj1 = 0 ;
30402 char *kwnames[] = {
30403 (char *) "self",(char *) "rect", NULL
30404 };
30405
30406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30408 if (SWIG_arg_fail(1)) SWIG_fail;
30409 {
30410 arg2 = &temp2;
30411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30412 }
30413 {
30414 PyThreadState* __tstate = wxPyBeginAllowThreads();
30415 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30416
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 {
30421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30422 }
30423 return resultobj;
30424 fail:
30425 return NULL;
30426 }
30427
30428
30429 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30430 PyObject *resultobj = NULL;
30431 wxWindow *arg1 = (wxWindow *) 0 ;
30432 wxVisualAttributes result;
30433 PyObject * obj0 = 0 ;
30434 char *kwnames[] = {
30435 (char *) "self", NULL
30436 };
30437
30438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30440 if (SWIG_arg_fail(1)) SWIG_fail;
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30444
30445 wxPyEndAllowThreads(__tstate);
30446 if (PyErr_Occurred()) SWIG_fail;
30447 }
30448 {
30449 wxVisualAttributes * resultptr;
30450 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30451 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj = NULL;
30461 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30462 wxVisualAttributes result;
30463 PyObject * obj0 = 0 ;
30464 char *kwnames[] = {
30465 (char *) "variant", NULL
30466 };
30467
30468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30469 if (obj0) {
30470 {
30471 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30472 if (SWIG_arg_fail(1)) SWIG_fail;
30473 }
30474 }
30475 {
30476 if (!wxPyCheckForApp()) SWIG_fail;
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = wxWindow::GetClassDefaultAttributes(arg1);
30479
30480 wxPyEndAllowThreads(__tstate);
30481 if (PyErr_Occurred()) SWIG_fail;
30482 }
30483 {
30484 wxVisualAttributes * resultptr;
30485 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30486 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30487 }
30488 return resultobj;
30489 fail:
30490 return NULL;
30491 }
30492
30493
30494 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30495 PyObject *resultobj = NULL;
30496 wxWindow *arg1 = (wxWindow *) 0 ;
30497 wxColour *arg2 = 0 ;
30498 bool result;
30499 wxColour temp2 ;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 char *kwnames[] = {
30503 (char *) "self",(char *) "colour", NULL
30504 };
30505
30506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30508 if (SWIG_arg_fail(1)) SWIG_fail;
30509 {
30510 arg2 = &temp2;
30511 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30512 }
30513 {
30514 PyThreadState* __tstate = wxPyBeginAllowThreads();
30515 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30516
30517 wxPyEndAllowThreads(__tstate);
30518 if (PyErr_Occurred()) SWIG_fail;
30519 }
30520 {
30521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30522 }
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30530 PyObject *resultobj = NULL;
30531 wxWindow *arg1 = (wxWindow *) 0 ;
30532 wxColour *arg2 = 0 ;
30533 wxColour temp2 ;
30534 PyObject * obj0 = 0 ;
30535 PyObject * obj1 = 0 ;
30536 char *kwnames[] = {
30537 (char *) "self",(char *) "colour", NULL
30538 };
30539
30540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30542 if (SWIG_arg_fail(1)) SWIG_fail;
30543 {
30544 arg2 = &temp2;
30545 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30546 }
30547 {
30548 PyThreadState* __tstate = wxPyBeginAllowThreads();
30549 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30550
30551 wxPyEndAllowThreads(__tstate);
30552 if (PyErr_Occurred()) SWIG_fail;
30553 }
30554 Py_INCREF(Py_None); resultobj = Py_None;
30555 return resultobj;
30556 fail:
30557 return NULL;
30558 }
30559
30560
30561 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30562 PyObject *resultobj = NULL;
30563 wxWindow *arg1 = (wxWindow *) 0 ;
30564 wxColour *arg2 = 0 ;
30565 bool result;
30566 wxColour temp2 ;
30567 PyObject * obj0 = 0 ;
30568 PyObject * obj1 = 0 ;
30569 char *kwnames[] = {
30570 (char *) "self",(char *) "colour", NULL
30571 };
30572
30573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30575 if (SWIG_arg_fail(1)) SWIG_fail;
30576 {
30577 arg2 = &temp2;
30578 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30579 }
30580 {
30581 PyThreadState* __tstate = wxPyBeginAllowThreads();
30582 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30583
30584 wxPyEndAllowThreads(__tstate);
30585 if (PyErr_Occurred()) SWIG_fail;
30586 }
30587 {
30588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30589 }
30590 return resultobj;
30591 fail:
30592 return NULL;
30593 }
30594
30595
30596 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30597 PyObject *resultobj = NULL;
30598 wxWindow *arg1 = (wxWindow *) 0 ;
30599 wxColour *arg2 = 0 ;
30600 wxColour temp2 ;
30601 PyObject * obj0 = 0 ;
30602 PyObject * obj1 = 0 ;
30603 char *kwnames[] = {
30604 (char *) "self",(char *) "colour", NULL
30605 };
30606
30607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30609 if (SWIG_arg_fail(1)) SWIG_fail;
30610 {
30611 arg2 = &temp2;
30612 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30613 }
30614 {
30615 PyThreadState* __tstate = wxPyBeginAllowThreads();
30616 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30617
30618 wxPyEndAllowThreads(__tstate);
30619 if (PyErr_Occurred()) SWIG_fail;
30620 }
30621 Py_INCREF(Py_None); resultobj = Py_None;
30622 return resultobj;
30623 fail:
30624 return NULL;
30625 }
30626
30627
30628 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30629 PyObject *resultobj = NULL;
30630 wxWindow *arg1 = (wxWindow *) 0 ;
30631 wxColour result;
30632 PyObject * obj0 = 0 ;
30633 char *kwnames[] = {
30634 (char *) "self", NULL
30635 };
30636
30637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30639 if (SWIG_arg_fail(1)) SWIG_fail;
30640 {
30641 PyThreadState* __tstate = wxPyBeginAllowThreads();
30642 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30643
30644 wxPyEndAllowThreads(__tstate);
30645 if (PyErr_Occurred()) SWIG_fail;
30646 }
30647 {
30648 wxColour * resultptr;
30649 resultptr = new wxColour(static_cast<wxColour & >(result));
30650 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30651 }
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30659 PyObject *resultobj = NULL;
30660 wxWindow *arg1 = (wxWindow *) 0 ;
30661 wxColour result;
30662 PyObject * obj0 = 0 ;
30663 char *kwnames[] = {
30664 (char *) "self", NULL
30665 };
30666
30667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30669 if (SWIG_arg_fail(1)) SWIG_fail;
30670 {
30671 PyThreadState* __tstate = wxPyBeginAllowThreads();
30672 result = ((wxWindow const *)arg1)->GetForegroundColour();
30673
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 {
30678 wxColour * resultptr;
30679 resultptr = new wxColour(static_cast<wxColour & >(result));
30680 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30681 }
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30689 PyObject *resultobj = NULL;
30690 wxWindow *arg1 = (wxWindow *) 0 ;
30691 bool result;
30692 PyObject * obj0 = 0 ;
30693 char *kwnames[] = {
30694 (char *) "self", NULL
30695 };
30696
30697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30699 if (SWIG_arg_fail(1)) SWIG_fail;
30700 {
30701 PyThreadState* __tstate = wxPyBeginAllowThreads();
30702 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30703
30704 wxPyEndAllowThreads(__tstate);
30705 if (PyErr_Occurred()) SWIG_fail;
30706 }
30707 {
30708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30709 }
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj = NULL;
30718 wxWindow *arg1 = (wxWindow *) 0 ;
30719 bool result;
30720 PyObject * obj0 = 0 ;
30721 char *kwnames[] = {
30722 (char *) "self", NULL
30723 };
30724
30725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30727 if (SWIG_arg_fail(1)) SWIG_fail;
30728 {
30729 PyThreadState* __tstate = wxPyBeginAllowThreads();
30730 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30731
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 {
30736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30737 }
30738 return resultobj;
30739 fail:
30740 return NULL;
30741 }
30742
30743
30744 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30745 PyObject *resultobj = NULL;
30746 wxWindow *arg1 = (wxWindow *) 0 ;
30747 wxBackgroundStyle arg2 ;
30748 bool result;
30749 PyObject * obj0 = 0 ;
30750 PyObject * obj1 = 0 ;
30751 char *kwnames[] = {
30752 (char *) "self",(char *) "style", NULL
30753 };
30754
30755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30757 if (SWIG_arg_fail(1)) SWIG_fail;
30758 {
30759 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30760 if (SWIG_arg_fail(2)) SWIG_fail;
30761 }
30762 {
30763 PyThreadState* __tstate = wxPyBeginAllowThreads();
30764 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30765
30766 wxPyEndAllowThreads(__tstate);
30767 if (PyErr_Occurred()) SWIG_fail;
30768 }
30769 {
30770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30771 }
30772 return resultobj;
30773 fail:
30774 return NULL;
30775 }
30776
30777
30778 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30779 PyObject *resultobj = NULL;
30780 wxWindow *arg1 = (wxWindow *) 0 ;
30781 wxBackgroundStyle result;
30782 PyObject * obj0 = 0 ;
30783 char *kwnames[] = {
30784 (char *) "self", NULL
30785 };
30786
30787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30789 if (SWIG_arg_fail(1)) SWIG_fail;
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30793
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 resultobj = SWIG_From_int((result));
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj = NULL;
30806 wxWindow *arg1 = (wxWindow *) 0 ;
30807 bool result;
30808 PyObject * obj0 = 0 ;
30809 char *kwnames[] = {
30810 (char *) "self", NULL
30811 };
30812
30813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30815 if (SWIG_arg_fail(1)) SWIG_fail;
30816 {
30817 PyThreadState* __tstate = wxPyBeginAllowThreads();
30818 result = (bool)(arg1)->HasTransparentBackground();
30819
30820 wxPyEndAllowThreads(__tstate);
30821 if (PyErr_Occurred()) SWIG_fail;
30822 }
30823 {
30824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30825 }
30826 return resultobj;
30827 fail:
30828 return NULL;
30829 }
30830
30831
30832 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30833 PyObject *resultobj = NULL;
30834 wxWindow *arg1 = (wxWindow *) 0 ;
30835 wxCursor *arg2 = 0 ;
30836 bool result;
30837 PyObject * obj0 = 0 ;
30838 PyObject * obj1 = 0 ;
30839 char *kwnames[] = {
30840 (char *) "self",(char *) "cursor", NULL
30841 };
30842
30843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30845 if (SWIG_arg_fail(1)) SWIG_fail;
30846 {
30847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30848 if (SWIG_arg_fail(2)) SWIG_fail;
30849 if (arg2 == NULL) {
30850 SWIG_null_ref("wxCursor");
30851 }
30852 if (SWIG_arg_fail(2)) SWIG_fail;
30853 }
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30857
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 {
30862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30863 }
30864 return resultobj;
30865 fail:
30866 return NULL;
30867 }
30868
30869
30870 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30871 PyObject *resultobj = NULL;
30872 wxWindow *arg1 = (wxWindow *) 0 ;
30873 wxCursor result;
30874 PyObject * obj0 = 0 ;
30875 char *kwnames[] = {
30876 (char *) "self", NULL
30877 };
30878
30879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30881 if (SWIG_arg_fail(1)) SWIG_fail;
30882 {
30883 PyThreadState* __tstate = wxPyBeginAllowThreads();
30884 result = (arg1)->GetCursor();
30885
30886 wxPyEndAllowThreads(__tstate);
30887 if (PyErr_Occurred()) SWIG_fail;
30888 }
30889 {
30890 wxCursor * resultptr;
30891 resultptr = new wxCursor(static_cast<wxCursor & >(result));
30892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30893 }
30894 return resultobj;
30895 fail:
30896 return NULL;
30897 }
30898
30899
30900 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30901 PyObject *resultobj = NULL;
30902 wxWindow *arg1 = (wxWindow *) 0 ;
30903 wxFont *arg2 = 0 ;
30904 bool result;
30905 PyObject * obj0 = 0 ;
30906 PyObject * obj1 = 0 ;
30907 char *kwnames[] = {
30908 (char *) "self",(char *) "font", NULL
30909 };
30910
30911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30913 if (SWIG_arg_fail(1)) SWIG_fail;
30914 {
30915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30916 if (SWIG_arg_fail(2)) SWIG_fail;
30917 if (arg2 == NULL) {
30918 SWIG_null_ref("wxFont");
30919 }
30920 if (SWIG_arg_fail(2)) SWIG_fail;
30921 }
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30925
30926 wxPyEndAllowThreads(__tstate);
30927 if (PyErr_Occurred()) SWIG_fail;
30928 }
30929 {
30930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30931 }
30932 return resultobj;
30933 fail:
30934 return NULL;
30935 }
30936
30937
30938 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30939 PyObject *resultobj = NULL;
30940 wxWindow *arg1 = (wxWindow *) 0 ;
30941 wxFont *arg2 = 0 ;
30942 PyObject * obj0 = 0 ;
30943 PyObject * obj1 = 0 ;
30944 char *kwnames[] = {
30945 (char *) "self",(char *) "font", NULL
30946 };
30947
30948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30950 if (SWIG_arg_fail(1)) SWIG_fail;
30951 {
30952 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30953 if (SWIG_arg_fail(2)) SWIG_fail;
30954 if (arg2 == NULL) {
30955 SWIG_null_ref("wxFont");
30956 }
30957 if (SWIG_arg_fail(2)) SWIG_fail;
30958 }
30959 {
30960 PyThreadState* __tstate = wxPyBeginAllowThreads();
30961 (arg1)->SetOwnFont((wxFont const &)*arg2);
30962
30963 wxPyEndAllowThreads(__tstate);
30964 if (PyErr_Occurred()) SWIG_fail;
30965 }
30966 Py_INCREF(Py_None); resultobj = Py_None;
30967 return resultobj;
30968 fail:
30969 return NULL;
30970 }
30971
30972
30973 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30974 PyObject *resultobj = NULL;
30975 wxWindow *arg1 = (wxWindow *) 0 ;
30976 wxFont result;
30977 PyObject * obj0 = 0 ;
30978 char *kwnames[] = {
30979 (char *) "self", NULL
30980 };
30981
30982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30984 if (SWIG_arg_fail(1)) SWIG_fail;
30985 {
30986 PyThreadState* __tstate = wxPyBeginAllowThreads();
30987 result = (arg1)->GetFont();
30988
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 {
30993 wxFont * resultptr;
30994 resultptr = new wxFont(static_cast<wxFont & >(result));
30995 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30996 }
30997 return resultobj;
30998 fail:
30999 return NULL;
31000 }
31001
31002
31003 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31004 PyObject *resultobj = NULL;
31005 wxWindow *arg1 = (wxWindow *) 0 ;
31006 wxCaret *arg2 = (wxCaret *) 0 ;
31007 PyObject * obj0 = 0 ;
31008 PyObject * obj1 = 0 ;
31009 char *kwnames[] = {
31010 (char *) "self",(char *) "caret", NULL
31011 };
31012
31013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
31014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31015 if (SWIG_arg_fail(1)) SWIG_fail;
31016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31017 if (SWIG_arg_fail(2)) SWIG_fail;
31018 {
31019 PyThreadState* __tstate = wxPyBeginAllowThreads();
31020 (arg1)->SetCaret(arg2);
31021
31022 wxPyEndAllowThreads(__tstate);
31023 if (PyErr_Occurred()) SWIG_fail;
31024 }
31025 Py_INCREF(Py_None); resultobj = Py_None;
31026 return resultobj;
31027 fail:
31028 return NULL;
31029 }
31030
31031
31032 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31033 PyObject *resultobj = NULL;
31034 wxWindow *arg1 = (wxWindow *) 0 ;
31035 wxCaret *result;
31036 PyObject * obj0 = 0 ;
31037 char *kwnames[] = {
31038 (char *) "self", NULL
31039 };
31040
31041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
31042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31043 if (SWIG_arg_fail(1)) SWIG_fail;
31044 {
31045 PyThreadState* __tstate = wxPyBeginAllowThreads();
31046 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31047
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31059 PyObject *resultobj = NULL;
31060 wxWindow *arg1 = (wxWindow *) 0 ;
31061 int result;
31062 PyObject * obj0 = 0 ;
31063 char *kwnames[] = {
31064 (char *) "self", NULL
31065 };
31066
31067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31069 if (SWIG_arg_fail(1)) SWIG_fail;
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31073
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 {
31078 resultobj = SWIG_From_int(static_cast<int >(result));
31079 }
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31087 PyObject *resultobj = NULL;
31088 wxWindow *arg1 = (wxWindow *) 0 ;
31089 int result;
31090 PyObject * obj0 = 0 ;
31091 char *kwnames[] = {
31092 (char *) "self", NULL
31093 };
31094
31095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31097 if (SWIG_arg_fail(1)) SWIG_fail;
31098 {
31099 PyThreadState* __tstate = wxPyBeginAllowThreads();
31100 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31101
31102 wxPyEndAllowThreads(__tstate);
31103 if (PyErr_Occurred()) SWIG_fail;
31104 }
31105 {
31106 resultobj = SWIG_From_int(static_cast<int >(result));
31107 }
31108 return resultobj;
31109 fail:
31110 return NULL;
31111 }
31112
31113
31114 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31115 PyObject *resultobj = NULL;
31116 wxWindow *arg1 = (wxWindow *) 0 ;
31117 wxString *arg2 = 0 ;
31118 int *arg3 = (int *) 0 ;
31119 int *arg4 = (int *) 0 ;
31120 bool temp2 = false ;
31121 int temp3 ;
31122 int res3 = 0 ;
31123 int temp4 ;
31124 int res4 = 0 ;
31125 PyObject * obj0 = 0 ;
31126 PyObject * obj1 = 0 ;
31127 char *kwnames[] = {
31128 (char *) "self",(char *) "string", NULL
31129 };
31130
31131 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31132 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31135 if (SWIG_arg_fail(1)) SWIG_fail;
31136 {
31137 arg2 = wxString_in_helper(obj1);
31138 if (arg2 == NULL) SWIG_fail;
31139 temp2 = true;
31140 }
31141 {
31142 PyThreadState* __tstate = wxPyBeginAllowThreads();
31143 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
31144
31145 wxPyEndAllowThreads(__tstate);
31146 if (PyErr_Occurred()) SWIG_fail;
31147 }
31148 Py_INCREF(Py_None); resultobj = Py_None;
31149 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31150 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31151 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31152 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31153 {
31154 if (temp2)
31155 delete arg2;
31156 }
31157 return resultobj;
31158 fail:
31159 {
31160 if (temp2)
31161 delete arg2;
31162 }
31163 return NULL;
31164 }
31165
31166
31167 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31168 PyObject *resultobj = NULL;
31169 wxWindow *arg1 = (wxWindow *) 0 ;
31170 wxString *arg2 = 0 ;
31171 int *arg3 = (int *) 0 ;
31172 int *arg4 = (int *) 0 ;
31173 int *arg5 = (int *) 0 ;
31174 int *arg6 = (int *) 0 ;
31175 wxFont *arg7 = (wxFont *) NULL ;
31176 bool temp2 = false ;
31177 int temp3 ;
31178 int res3 = 0 ;
31179 int temp4 ;
31180 int res4 = 0 ;
31181 int temp5 ;
31182 int res5 = 0 ;
31183 int temp6 ;
31184 int res6 = 0 ;
31185 PyObject * obj0 = 0 ;
31186 PyObject * obj1 = 0 ;
31187 PyObject * obj2 = 0 ;
31188 char *kwnames[] = {
31189 (char *) "self",(char *) "string",(char *) "font", NULL
31190 };
31191
31192 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31193 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31194 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31195 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31198 if (SWIG_arg_fail(1)) SWIG_fail;
31199 {
31200 arg2 = wxString_in_helper(obj1);
31201 if (arg2 == NULL) SWIG_fail;
31202 temp2 = true;
31203 }
31204 if (obj2) {
31205 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31206 if (SWIG_arg_fail(7)) SWIG_fail;
31207 }
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31211
31212 wxPyEndAllowThreads(__tstate);
31213 if (PyErr_Occurred()) SWIG_fail;
31214 }
31215 Py_INCREF(Py_None); resultobj = Py_None;
31216 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31217 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31218 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31219 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31220 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31221 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31222 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31223 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31224 {
31225 if (temp2)
31226 delete arg2;
31227 }
31228 return resultobj;
31229 fail:
31230 {
31231 if (temp2)
31232 delete arg2;
31233 }
31234 return NULL;
31235 }
31236
31237
31238 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31239 PyObject *resultobj = NULL;
31240 wxWindow *arg1 = (wxWindow *) 0 ;
31241 int *arg2 = (int *) 0 ;
31242 int *arg3 = (int *) 0 ;
31243 int temp2 ;
31244 int res2 = 0 ;
31245 int temp3 ;
31246 int res3 = 0 ;
31247 PyObject * obj0 = 0 ;
31248 PyObject * obj1 = 0 ;
31249 PyObject * obj2 = 0 ;
31250 char *kwnames[] = {
31251 (char *) "self",(char *) "x",(char *) "y", NULL
31252 };
31253
31254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31256 if (SWIG_arg_fail(1)) SWIG_fail;
31257 {
31258 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31259 temp2 = SWIG_As_int(obj1);
31260 if (SWIG_arg_fail(2)) SWIG_fail;
31261 arg2 = &temp2;
31262 res2 = SWIG_NEWOBJ;
31263 }
31264 }
31265 {
31266 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31267 temp3 = SWIG_As_int(obj2);
31268 if (SWIG_arg_fail(3)) SWIG_fail;
31269 arg3 = &temp3;
31270 res3 = SWIG_NEWOBJ;
31271 }
31272 }
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31276
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 Py_INCREF(Py_None); resultobj = Py_None;
31281 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31282 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31283 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31284 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31285 return resultobj;
31286 fail:
31287 return NULL;
31288 }
31289
31290
31291 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31292 PyObject *resultobj = NULL;
31293 wxWindow *arg1 = (wxWindow *) 0 ;
31294 int *arg2 = (int *) 0 ;
31295 int *arg3 = (int *) 0 ;
31296 int temp2 ;
31297 int res2 = 0 ;
31298 int temp3 ;
31299 int res3 = 0 ;
31300 PyObject * obj0 = 0 ;
31301 PyObject * obj1 = 0 ;
31302 PyObject * obj2 = 0 ;
31303 char *kwnames[] = {
31304 (char *) "self",(char *) "x",(char *) "y", NULL
31305 };
31306
31307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31309 if (SWIG_arg_fail(1)) SWIG_fail;
31310 {
31311 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31312 temp2 = SWIG_As_int(obj1);
31313 if (SWIG_arg_fail(2)) SWIG_fail;
31314 arg2 = &temp2;
31315 res2 = SWIG_NEWOBJ;
31316 }
31317 }
31318 {
31319 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31320 temp3 = SWIG_As_int(obj2);
31321 if (SWIG_arg_fail(3)) SWIG_fail;
31322 arg3 = &temp3;
31323 res3 = SWIG_NEWOBJ;
31324 }
31325 }
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31329
31330 wxPyEndAllowThreads(__tstate);
31331 if (PyErr_Occurred()) SWIG_fail;
31332 }
31333 Py_INCREF(Py_None); resultobj = Py_None;
31334 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31335 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31336 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31337 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31345 PyObject *resultobj = NULL;
31346 wxWindow *arg1 = (wxWindow *) 0 ;
31347 wxPoint *arg2 = 0 ;
31348 wxPoint result;
31349 wxPoint temp2 ;
31350 PyObject * obj0 = 0 ;
31351 PyObject * obj1 = 0 ;
31352 char *kwnames[] = {
31353 (char *) "self",(char *) "pt", NULL
31354 };
31355
31356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31358 if (SWIG_arg_fail(1)) SWIG_fail;
31359 {
31360 arg2 = &temp2;
31361 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31362 }
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31366
31367 wxPyEndAllowThreads(__tstate);
31368 if (PyErr_Occurred()) SWIG_fail;
31369 }
31370 {
31371 wxPoint * resultptr;
31372 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31373 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31374 }
31375 return resultobj;
31376 fail:
31377 return NULL;
31378 }
31379
31380
31381 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31382 PyObject *resultobj = NULL;
31383 wxWindow *arg1 = (wxWindow *) 0 ;
31384 wxPoint *arg2 = 0 ;
31385 wxPoint result;
31386 wxPoint temp2 ;
31387 PyObject * obj0 = 0 ;
31388 PyObject * obj1 = 0 ;
31389 char *kwnames[] = {
31390 (char *) "self",(char *) "pt", NULL
31391 };
31392
31393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31395 if (SWIG_arg_fail(1)) SWIG_fail;
31396 {
31397 arg2 = &temp2;
31398 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31399 }
31400 {
31401 PyThreadState* __tstate = wxPyBeginAllowThreads();
31402 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31403
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 {
31408 wxPoint * resultptr;
31409 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31411 }
31412 return resultobj;
31413 fail:
31414 return NULL;
31415 }
31416
31417
31418 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31419 PyObject *resultobj = NULL;
31420 wxWindow *arg1 = (wxWindow *) 0 ;
31421 int arg2 ;
31422 int arg3 ;
31423 wxHitTest result;
31424 PyObject * obj0 = 0 ;
31425 PyObject * obj1 = 0 ;
31426 PyObject * obj2 = 0 ;
31427 char *kwnames[] = {
31428 (char *) "self",(char *) "x",(char *) "y", NULL
31429 };
31430
31431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31433 if (SWIG_arg_fail(1)) SWIG_fail;
31434 {
31435 arg2 = static_cast<int >(SWIG_As_int(obj1));
31436 if (SWIG_arg_fail(2)) SWIG_fail;
31437 }
31438 {
31439 arg3 = static_cast<int >(SWIG_As_int(obj2));
31440 if (SWIG_arg_fail(3)) SWIG_fail;
31441 }
31442 {
31443 PyThreadState* __tstate = wxPyBeginAllowThreads();
31444 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31445
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 resultobj = SWIG_From_int((result));
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj = NULL;
31458 wxWindow *arg1 = (wxWindow *) 0 ;
31459 wxPoint *arg2 = 0 ;
31460 wxHitTest result;
31461 wxPoint temp2 ;
31462 PyObject * obj0 = 0 ;
31463 PyObject * obj1 = 0 ;
31464 char *kwnames[] = {
31465 (char *) "self",(char *) "pt", NULL
31466 };
31467
31468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31470 if (SWIG_arg_fail(1)) SWIG_fail;
31471 {
31472 arg2 = &temp2;
31473 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31474 }
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31478
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 resultobj = SWIG_From_int((result));
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31490 PyObject *resultobj = NULL;
31491 wxWindow *arg1 = (wxWindow *) 0 ;
31492 long arg2 ;
31493 wxBorder result;
31494 PyObject * obj0 = 0 ;
31495 PyObject * obj1 = 0 ;
31496
31497 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31499 if (SWIG_arg_fail(1)) SWIG_fail;
31500 {
31501 arg2 = static_cast<long >(SWIG_As_long(obj1));
31502 if (SWIG_arg_fail(2)) SWIG_fail;
31503 }
31504 {
31505 PyThreadState* __tstate = wxPyBeginAllowThreads();
31506 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31507
31508 wxPyEndAllowThreads(__tstate);
31509 if (PyErr_Occurred()) SWIG_fail;
31510 }
31511 resultobj = SWIG_From_int((result));
31512 return resultobj;
31513 fail:
31514 return NULL;
31515 }
31516
31517
31518 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31519 PyObject *resultobj = NULL;
31520 wxWindow *arg1 = (wxWindow *) 0 ;
31521 wxBorder result;
31522 PyObject * obj0 = 0 ;
31523
31524 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
31529 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31530
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 resultobj = SWIG_From_int((result));
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31542 int argc;
31543 PyObject *argv[3];
31544 int ii;
31545
31546 argc = PyObject_Length(args);
31547 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31548 argv[ii] = PyTuple_GetItem(args,ii);
31549 }
31550 if (argc == 1) {
31551 int _v;
31552 {
31553 void *ptr;
31554 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31555 _v = 0;
31556 PyErr_Clear();
31557 } else {
31558 _v = 1;
31559 }
31560 }
31561 if (_v) {
31562 return _wrap_Window_GetBorder__SWIG_1(self,args);
31563 }
31564 }
31565 if (argc == 2) {
31566 int _v;
31567 {
31568 void *ptr;
31569 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31570 _v = 0;
31571 PyErr_Clear();
31572 } else {
31573 _v = 1;
31574 }
31575 }
31576 if (_v) {
31577 _v = SWIG_Check_long(argv[1]);
31578 if (_v) {
31579 return _wrap_Window_GetBorder__SWIG_0(self,args);
31580 }
31581 }
31582 }
31583
31584 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31585 return NULL;
31586 }
31587
31588
31589 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31590 PyObject *resultobj = NULL;
31591 wxWindow *arg1 = (wxWindow *) 0 ;
31592 long arg2 = (long) wxUPDATE_UI_NONE ;
31593 PyObject * obj0 = 0 ;
31594 PyObject * obj1 = 0 ;
31595 char *kwnames[] = {
31596 (char *) "self",(char *) "flags", NULL
31597 };
31598
31599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31601 if (SWIG_arg_fail(1)) SWIG_fail;
31602 if (obj1) {
31603 {
31604 arg2 = static_cast<long >(SWIG_As_long(obj1));
31605 if (SWIG_arg_fail(2)) SWIG_fail;
31606 }
31607 }
31608 {
31609 PyThreadState* __tstate = wxPyBeginAllowThreads();
31610 (arg1)->UpdateWindowUI(arg2);
31611
31612 wxPyEndAllowThreads(__tstate);
31613 if (PyErr_Occurred()) SWIG_fail;
31614 }
31615 Py_INCREF(Py_None); resultobj = Py_None;
31616 return resultobj;
31617 fail:
31618 return NULL;
31619 }
31620
31621
31622 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31623 PyObject *resultobj = NULL;
31624 wxWindow *arg1 = (wxWindow *) 0 ;
31625 wxMenu *arg2 = (wxMenu *) 0 ;
31626 int arg3 = (int) -1 ;
31627 int arg4 = (int) -1 ;
31628 bool result;
31629 PyObject * obj0 = 0 ;
31630 PyObject * obj1 = 0 ;
31631 PyObject * obj2 = 0 ;
31632 PyObject * obj3 = 0 ;
31633 char *kwnames[] = {
31634 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31635 };
31636
31637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31639 if (SWIG_arg_fail(1)) SWIG_fail;
31640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31641 if (SWIG_arg_fail(2)) SWIG_fail;
31642 if (obj2) {
31643 {
31644 arg3 = static_cast<int >(SWIG_As_int(obj2));
31645 if (SWIG_arg_fail(3)) SWIG_fail;
31646 }
31647 }
31648 if (obj3) {
31649 {
31650 arg4 = static_cast<int >(SWIG_As_int(obj3));
31651 if (SWIG_arg_fail(4)) SWIG_fail;
31652 }
31653 }
31654 {
31655 PyThreadState* __tstate = wxPyBeginAllowThreads();
31656 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31657
31658 wxPyEndAllowThreads(__tstate);
31659 if (PyErr_Occurred()) SWIG_fail;
31660 }
31661 {
31662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31663 }
31664 return resultobj;
31665 fail:
31666 return NULL;
31667 }
31668
31669
31670 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31671 PyObject *resultobj = NULL;
31672 wxWindow *arg1 = (wxWindow *) 0 ;
31673 wxMenu *arg2 = (wxMenu *) 0 ;
31674 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31675 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31676 bool result;
31677 wxPoint temp3 ;
31678 PyObject * obj0 = 0 ;
31679 PyObject * obj1 = 0 ;
31680 PyObject * obj2 = 0 ;
31681 char *kwnames[] = {
31682 (char *) "self",(char *) "menu",(char *) "pos", NULL
31683 };
31684
31685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31687 if (SWIG_arg_fail(1)) SWIG_fail;
31688 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31689 if (SWIG_arg_fail(2)) SWIG_fail;
31690 if (obj2) {
31691 {
31692 arg3 = &temp3;
31693 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31694 }
31695 }
31696 {
31697 PyThreadState* __tstate = wxPyBeginAllowThreads();
31698 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31699
31700 wxPyEndAllowThreads(__tstate);
31701 if (PyErr_Occurred()) SWIG_fail;
31702 }
31703 {
31704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31705 }
31706 return resultobj;
31707 fail:
31708 return NULL;
31709 }
31710
31711
31712 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31713 PyObject *resultobj = NULL;
31714 wxWindow *arg1 = (wxWindow *) 0 ;
31715 long result;
31716 PyObject * obj0 = 0 ;
31717 char *kwnames[] = {
31718 (char *) "self", NULL
31719 };
31720
31721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31723 if (SWIG_arg_fail(1)) SWIG_fail;
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 result = (long)wxWindow_GetHandle(arg1);
31727
31728 wxPyEndAllowThreads(__tstate);
31729 if (PyErr_Occurred()) SWIG_fail;
31730 }
31731 {
31732 resultobj = SWIG_From_long(static_cast<long >(result));
31733 }
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31741 PyObject *resultobj = NULL;
31742 wxWindow *arg1 = (wxWindow *) 0 ;
31743 long arg2 ;
31744 PyObject * obj0 = 0 ;
31745 PyObject * obj1 = 0 ;
31746 char *kwnames[] = {
31747 (char *) "self",(char *) "handle", NULL
31748 };
31749
31750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31752 if (SWIG_arg_fail(1)) SWIG_fail;
31753 {
31754 arg2 = static_cast<long >(SWIG_As_long(obj1));
31755 if (SWIG_arg_fail(2)) SWIG_fail;
31756 }
31757 {
31758 PyThreadState* __tstate = wxPyBeginAllowThreads();
31759 wxWindow_AssociateHandle(arg1,arg2);
31760
31761 wxPyEndAllowThreads(__tstate);
31762 if (PyErr_Occurred()) SWIG_fail;
31763 }
31764 Py_INCREF(Py_None); resultobj = Py_None;
31765 return resultobj;
31766 fail:
31767 return NULL;
31768 }
31769
31770
31771 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31772 PyObject *resultobj = NULL;
31773 wxWindow *arg1 = (wxWindow *) 0 ;
31774 PyObject * obj0 = 0 ;
31775 char *kwnames[] = {
31776 (char *) "self", NULL
31777 };
31778
31779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31781 if (SWIG_arg_fail(1)) SWIG_fail;
31782 {
31783 PyThreadState* __tstate = wxPyBeginAllowThreads();
31784 (arg1)->DissociateHandle();
31785
31786 wxPyEndAllowThreads(__tstate);
31787 if (PyErr_Occurred()) SWIG_fail;
31788 }
31789 Py_INCREF(Py_None); resultobj = Py_None;
31790 return resultobj;
31791 fail:
31792 return NULL;
31793 }
31794
31795
31796 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31797 PyObject *resultobj = NULL;
31798 wxWindow *arg1 = (wxWindow *) 0 ;
31799 int arg2 ;
31800 bool result;
31801 PyObject * obj0 = 0 ;
31802 PyObject * obj1 = 0 ;
31803 char *kwnames[] = {
31804 (char *) "self",(char *) "orient", NULL
31805 };
31806
31807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31809 if (SWIG_arg_fail(1)) SWIG_fail;
31810 {
31811 arg2 = static_cast<int >(SWIG_As_int(obj1));
31812 if (SWIG_arg_fail(2)) SWIG_fail;
31813 }
31814 {
31815 PyThreadState* __tstate = wxPyBeginAllowThreads();
31816 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31817
31818 wxPyEndAllowThreads(__tstate);
31819 if (PyErr_Occurred()) SWIG_fail;
31820 }
31821 {
31822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31823 }
31824 return resultobj;
31825 fail:
31826 return NULL;
31827 }
31828
31829
31830 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31831 PyObject *resultobj = NULL;
31832 wxWindow *arg1 = (wxWindow *) 0 ;
31833 int arg2 ;
31834 int arg3 ;
31835 int arg4 ;
31836 int arg5 ;
31837 bool arg6 = (bool) true ;
31838 PyObject * obj0 = 0 ;
31839 PyObject * obj1 = 0 ;
31840 PyObject * obj2 = 0 ;
31841 PyObject * obj3 = 0 ;
31842 PyObject * obj4 = 0 ;
31843 PyObject * obj5 = 0 ;
31844 char *kwnames[] = {
31845 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31846 };
31847
31848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31850 if (SWIG_arg_fail(1)) SWIG_fail;
31851 {
31852 arg2 = static_cast<int >(SWIG_As_int(obj1));
31853 if (SWIG_arg_fail(2)) SWIG_fail;
31854 }
31855 {
31856 arg3 = static_cast<int >(SWIG_As_int(obj2));
31857 if (SWIG_arg_fail(3)) SWIG_fail;
31858 }
31859 {
31860 arg4 = static_cast<int >(SWIG_As_int(obj3));
31861 if (SWIG_arg_fail(4)) SWIG_fail;
31862 }
31863 {
31864 arg5 = static_cast<int >(SWIG_As_int(obj4));
31865 if (SWIG_arg_fail(5)) SWIG_fail;
31866 }
31867 if (obj5) {
31868 {
31869 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31870 if (SWIG_arg_fail(6)) SWIG_fail;
31871 }
31872 }
31873 {
31874 PyThreadState* __tstate = wxPyBeginAllowThreads();
31875 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31876
31877 wxPyEndAllowThreads(__tstate);
31878 if (PyErr_Occurred()) SWIG_fail;
31879 }
31880 Py_INCREF(Py_None); resultobj = Py_None;
31881 return resultobj;
31882 fail:
31883 return NULL;
31884 }
31885
31886
31887 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31888 PyObject *resultobj = NULL;
31889 wxWindow *arg1 = (wxWindow *) 0 ;
31890 int arg2 ;
31891 int arg3 ;
31892 bool arg4 = (bool) true ;
31893 PyObject * obj0 = 0 ;
31894 PyObject * obj1 = 0 ;
31895 PyObject * obj2 = 0 ;
31896 PyObject * obj3 = 0 ;
31897 char *kwnames[] = {
31898 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31899 };
31900
31901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31903 if (SWIG_arg_fail(1)) SWIG_fail;
31904 {
31905 arg2 = static_cast<int >(SWIG_As_int(obj1));
31906 if (SWIG_arg_fail(2)) SWIG_fail;
31907 }
31908 {
31909 arg3 = static_cast<int >(SWIG_As_int(obj2));
31910 if (SWIG_arg_fail(3)) SWIG_fail;
31911 }
31912 if (obj3) {
31913 {
31914 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
31915 if (SWIG_arg_fail(4)) SWIG_fail;
31916 }
31917 }
31918 {
31919 PyThreadState* __tstate = wxPyBeginAllowThreads();
31920 (arg1)->SetScrollPos(arg2,arg3,arg4);
31921
31922 wxPyEndAllowThreads(__tstate);
31923 if (PyErr_Occurred()) SWIG_fail;
31924 }
31925 Py_INCREF(Py_None); resultobj = Py_None;
31926 return resultobj;
31927 fail:
31928 return NULL;
31929 }
31930
31931
31932 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31933 PyObject *resultobj = NULL;
31934 wxWindow *arg1 = (wxWindow *) 0 ;
31935 int arg2 ;
31936 int result;
31937 PyObject * obj0 = 0 ;
31938 PyObject * obj1 = 0 ;
31939 char *kwnames[] = {
31940 (char *) "self",(char *) "orientation", NULL
31941 };
31942
31943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31945 if (SWIG_arg_fail(1)) SWIG_fail;
31946 {
31947 arg2 = static_cast<int >(SWIG_As_int(obj1));
31948 if (SWIG_arg_fail(2)) SWIG_fail;
31949 }
31950 {
31951 PyThreadState* __tstate = wxPyBeginAllowThreads();
31952 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31953
31954 wxPyEndAllowThreads(__tstate);
31955 if (PyErr_Occurred()) SWIG_fail;
31956 }
31957 {
31958 resultobj = SWIG_From_int(static_cast<int >(result));
31959 }
31960 return resultobj;
31961 fail:
31962 return NULL;
31963 }
31964
31965
31966 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31967 PyObject *resultobj = NULL;
31968 wxWindow *arg1 = (wxWindow *) 0 ;
31969 int arg2 ;
31970 int result;
31971 PyObject * obj0 = 0 ;
31972 PyObject * obj1 = 0 ;
31973 char *kwnames[] = {
31974 (char *) "self",(char *) "orientation", NULL
31975 };
31976
31977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31979 if (SWIG_arg_fail(1)) SWIG_fail;
31980 {
31981 arg2 = static_cast<int >(SWIG_As_int(obj1));
31982 if (SWIG_arg_fail(2)) SWIG_fail;
31983 }
31984 {
31985 PyThreadState* __tstate = wxPyBeginAllowThreads();
31986 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31987
31988 wxPyEndAllowThreads(__tstate);
31989 if (PyErr_Occurred()) SWIG_fail;
31990 }
31991 {
31992 resultobj = SWIG_From_int(static_cast<int >(result));
31993 }
31994 return resultobj;
31995 fail:
31996 return NULL;
31997 }
31998
31999
32000 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
32001 PyObject *resultobj = NULL;
32002 wxWindow *arg1 = (wxWindow *) 0 ;
32003 int arg2 ;
32004 int result;
32005 PyObject * obj0 = 0 ;
32006 PyObject * obj1 = 0 ;
32007 char *kwnames[] = {
32008 (char *) "self",(char *) "orientation", NULL
32009 };
32010
32011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32013 if (SWIG_arg_fail(1)) SWIG_fail;
32014 {
32015 arg2 = static_cast<int >(SWIG_As_int(obj1));
32016 if (SWIG_arg_fail(2)) SWIG_fail;
32017 }
32018 {
32019 PyThreadState* __tstate = wxPyBeginAllowThreads();
32020 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32021
32022 wxPyEndAllowThreads(__tstate);
32023 if (PyErr_Occurred()) SWIG_fail;
32024 }
32025 {
32026 resultobj = SWIG_From_int(static_cast<int >(result));
32027 }
32028 return resultobj;
32029 fail:
32030 return NULL;
32031 }
32032
32033
32034 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32035 PyObject *resultobj = NULL;
32036 wxWindow *arg1 = (wxWindow *) 0 ;
32037 int arg2 ;
32038 int arg3 ;
32039 wxRect *arg4 = (wxRect *) NULL ;
32040 PyObject * obj0 = 0 ;
32041 PyObject * obj1 = 0 ;
32042 PyObject * obj2 = 0 ;
32043 PyObject * obj3 = 0 ;
32044 char *kwnames[] = {
32045 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32046 };
32047
32048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32050 if (SWIG_arg_fail(1)) SWIG_fail;
32051 {
32052 arg2 = static_cast<int >(SWIG_As_int(obj1));
32053 if (SWIG_arg_fail(2)) SWIG_fail;
32054 }
32055 {
32056 arg3 = static_cast<int >(SWIG_As_int(obj2));
32057 if (SWIG_arg_fail(3)) SWIG_fail;
32058 }
32059 if (obj3) {
32060 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32061 if (SWIG_arg_fail(4)) SWIG_fail;
32062 }
32063 {
32064 PyThreadState* __tstate = wxPyBeginAllowThreads();
32065 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32066
32067 wxPyEndAllowThreads(__tstate);
32068 if (PyErr_Occurred()) SWIG_fail;
32069 }
32070 Py_INCREF(Py_None); resultobj = Py_None;
32071 return resultobj;
32072 fail:
32073 return NULL;
32074 }
32075
32076
32077 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32078 PyObject *resultobj = NULL;
32079 wxWindow *arg1 = (wxWindow *) 0 ;
32080 int arg2 ;
32081 bool result;
32082 PyObject * obj0 = 0 ;
32083 PyObject * obj1 = 0 ;
32084 char *kwnames[] = {
32085 (char *) "self",(char *) "lines", NULL
32086 };
32087
32088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32090 if (SWIG_arg_fail(1)) SWIG_fail;
32091 {
32092 arg2 = static_cast<int >(SWIG_As_int(obj1));
32093 if (SWIG_arg_fail(2)) SWIG_fail;
32094 }
32095 {
32096 PyThreadState* __tstate = wxPyBeginAllowThreads();
32097 result = (bool)(arg1)->ScrollLines(arg2);
32098
32099 wxPyEndAllowThreads(__tstate);
32100 if (PyErr_Occurred()) SWIG_fail;
32101 }
32102 {
32103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32104 }
32105 return resultobj;
32106 fail:
32107 return NULL;
32108 }
32109
32110
32111 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32112 PyObject *resultobj = NULL;
32113 wxWindow *arg1 = (wxWindow *) 0 ;
32114 int arg2 ;
32115 bool result;
32116 PyObject * obj0 = 0 ;
32117 PyObject * obj1 = 0 ;
32118 char *kwnames[] = {
32119 (char *) "self",(char *) "pages", NULL
32120 };
32121
32122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32124 if (SWIG_arg_fail(1)) SWIG_fail;
32125 {
32126 arg2 = static_cast<int >(SWIG_As_int(obj1));
32127 if (SWIG_arg_fail(2)) SWIG_fail;
32128 }
32129 {
32130 PyThreadState* __tstate = wxPyBeginAllowThreads();
32131 result = (bool)(arg1)->ScrollPages(arg2);
32132
32133 wxPyEndAllowThreads(__tstate);
32134 if (PyErr_Occurred()) SWIG_fail;
32135 }
32136 {
32137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32138 }
32139 return resultobj;
32140 fail:
32141 return NULL;
32142 }
32143
32144
32145 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32146 PyObject *resultobj = NULL;
32147 wxWindow *arg1 = (wxWindow *) 0 ;
32148 bool result;
32149 PyObject * obj0 = 0 ;
32150 char *kwnames[] = {
32151 (char *) "self", NULL
32152 };
32153
32154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32156 if (SWIG_arg_fail(1)) SWIG_fail;
32157 {
32158 PyThreadState* __tstate = wxPyBeginAllowThreads();
32159 result = (bool)(arg1)->LineUp();
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_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32174 PyObject *resultobj = NULL;
32175 wxWindow *arg1 = (wxWindow *) 0 ;
32176 bool result;
32177 PyObject * obj0 = 0 ;
32178 char *kwnames[] = {
32179 (char *) "self", NULL
32180 };
32181
32182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32184 if (SWIG_arg_fail(1)) SWIG_fail;
32185 {
32186 PyThreadState* __tstate = wxPyBeginAllowThreads();
32187 result = (bool)(arg1)->LineDown();
32188
32189 wxPyEndAllowThreads(__tstate);
32190 if (PyErr_Occurred()) SWIG_fail;
32191 }
32192 {
32193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32194 }
32195 return resultobj;
32196 fail:
32197 return NULL;
32198 }
32199
32200
32201 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32202 PyObject *resultobj = NULL;
32203 wxWindow *arg1 = (wxWindow *) 0 ;
32204 bool result;
32205 PyObject * obj0 = 0 ;
32206 char *kwnames[] = {
32207 (char *) "self", NULL
32208 };
32209
32210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32212 if (SWIG_arg_fail(1)) SWIG_fail;
32213 {
32214 PyThreadState* __tstate = wxPyBeginAllowThreads();
32215 result = (bool)(arg1)->PageUp();
32216
32217 wxPyEndAllowThreads(__tstate);
32218 if (PyErr_Occurred()) SWIG_fail;
32219 }
32220 {
32221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32222 }
32223 return resultobj;
32224 fail:
32225 return NULL;
32226 }
32227
32228
32229 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32230 PyObject *resultobj = NULL;
32231 wxWindow *arg1 = (wxWindow *) 0 ;
32232 bool result;
32233 PyObject * obj0 = 0 ;
32234 char *kwnames[] = {
32235 (char *) "self", NULL
32236 };
32237
32238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32240 if (SWIG_arg_fail(1)) SWIG_fail;
32241 {
32242 PyThreadState* __tstate = wxPyBeginAllowThreads();
32243 result = (bool)(arg1)->PageDown();
32244
32245 wxPyEndAllowThreads(__tstate);
32246 if (PyErr_Occurred()) SWIG_fail;
32247 }
32248 {
32249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32250 }
32251 return resultobj;
32252 fail:
32253 return NULL;
32254 }
32255
32256
32257 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32258 PyObject *resultobj = NULL;
32259 wxWindow *arg1 = (wxWindow *) 0 ;
32260 wxString *arg2 = 0 ;
32261 bool temp2 = false ;
32262 PyObject * obj0 = 0 ;
32263 PyObject * obj1 = 0 ;
32264 char *kwnames[] = {
32265 (char *) "self",(char *) "text", NULL
32266 };
32267
32268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32270 if (SWIG_arg_fail(1)) SWIG_fail;
32271 {
32272 arg2 = wxString_in_helper(obj1);
32273 if (arg2 == NULL) SWIG_fail;
32274 temp2 = true;
32275 }
32276 {
32277 PyThreadState* __tstate = wxPyBeginAllowThreads();
32278 (arg1)->SetHelpText((wxString const &)*arg2);
32279
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 Py_INCREF(Py_None); resultobj = Py_None;
32284 {
32285 if (temp2)
32286 delete arg2;
32287 }
32288 return resultobj;
32289 fail:
32290 {
32291 if (temp2)
32292 delete arg2;
32293 }
32294 return NULL;
32295 }
32296
32297
32298 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32299 PyObject *resultobj = NULL;
32300 wxWindow *arg1 = (wxWindow *) 0 ;
32301 wxString *arg2 = 0 ;
32302 bool temp2 = false ;
32303 PyObject * obj0 = 0 ;
32304 PyObject * obj1 = 0 ;
32305 char *kwnames[] = {
32306 (char *) "self",(char *) "text", NULL
32307 };
32308
32309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32311 if (SWIG_arg_fail(1)) SWIG_fail;
32312 {
32313 arg2 = wxString_in_helper(obj1);
32314 if (arg2 == NULL) SWIG_fail;
32315 temp2 = true;
32316 }
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32320
32321 wxPyEndAllowThreads(__tstate);
32322 if (PyErr_Occurred()) SWIG_fail;
32323 }
32324 Py_INCREF(Py_None); resultobj = Py_None;
32325 {
32326 if (temp2)
32327 delete arg2;
32328 }
32329 return resultobj;
32330 fail:
32331 {
32332 if (temp2)
32333 delete arg2;
32334 }
32335 return NULL;
32336 }
32337
32338
32339 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32340 PyObject *resultobj = NULL;
32341 wxWindow *arg1 = (wxWindow *) 0 ;
32342 wxString result;
32343 PyObject * obj0 = 0 ;
32344 char *kwnames[] = {
32345 (char *) "self", NULL
32346 };
32347
32348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32350 if (SWIG_arg_fail(1)) SWIG_fail;
32351 {
32352 PyThreadState* __tstate = wxPyBeginAllowThreads();
32353 result = ((wxWindow const *)arg1)->GetHelpText();
32354
32355 wxPyEndAllowThreads(__tstate);
32356 if (PyErr_Occurred()) SWIG_fail;
32357 }
32358 {
32359 #if wxUSE_UNICODE
32360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32361 #else
32362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32363 #endif
32364 }
32365 return resultobj;
32366 fail:
32367 return NULL;
32368 }
32369
32370
32371 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32372 PyObject *resultobj = NULL;
32373 wxWindow *arg1 = (wxWindow *) 0 ;
32374 wxString *arg2 = 0 ;
32375 bool temp2 = false ;
32376 PyObject * obj0 = 0 ;
32377 PyObject * obj1 = 0 ;
32378 char *kwnames[] = {
32379 (char *) "self",(char *) "tip", NULL
32380 };
32381
32382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32384 if (SWIG_arg_fail(1)) SWIG_fail;
32385 {
32386 arg2 = wxString_in_helper(obj1);
32387 if (arg2 == NULL) SWIG_fail;
32388 temp2 = true;
32389 }
32390 {
32391 PyThreadState* __tstate = wxPyBeginAllowThreads();
32392 (arg1)->SetToolTip((wxString const &)*arg2);
32393
32394 wxPyEndAllowThreads(__tstate);
32395 if (PyErr_Occurred()) SWIG_fail;
32396 }
32397 Py_INCREF(Py_None); resultobj = Py_None;
32398 {
32399 if (temp2)
32400 delete arg2;
32401 }
32402 return resultobj;
32403 fail:
32404 {
32405 if (temp2)
32406 delete arg2;
32407 }
32408 return NULL;
32409 }
32410
32411
32412 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32413 PyObject *resultobj = NULL;
32414 wxWindow *arg1 = (wxWindow *) 0 ;
32415 wxToolTip *arg2 = (wxToolTip *) 0 ;
32416 PyObject * obj0 = 0 ;
32417 PyObject * obj1 = 0 ;
32418 char *kwnames[] = {
32419 (char *) "self",(char *) "tip", NULL
32420 };
32421
32422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32424 if (SWIG_arg_fail(1)) SWIG_fail;
32425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32426 if (SWIG_arg_fail(2)) SWIG_fail;
32427 {
32428 PyThreadState* __tstate = wxPyBeginAllowThreads();
32429 (arg1)->SetToolTip(arg2);
32430
32431 wxPyEndAllowThreads(__tstate);
32432 if (PyErr_Occurred()) SWIG_fail;
32433 }
32434 Py_INCREF(Py_None); resultobj = Py_None;
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32442 PyObject *resultobj = NULL;
32443 wxWindow *arg1 = (wxWindow *) 0 ;
32444 wxToolTip *result;
32445 PyObject * obj0 = 0 ;
32446 char *kwnames[] = {
32447 (char *) "self", NULL
32448 };
32449
32450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32452 if (SWIG_arg_fail(1)) SWIG_fail;
32453 {
32454 PyThreadState* __tstate = wxPyBeginAllowThreads();
32455 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32456
32457 wxPyEndAllowThreads(__tstate);
32458 if (PyErr_Occurred()) SWIG_fail;
32459 }
32460 {
32461 resultobj = wxPyMake_wxObject(result, (bool)0);
32462 }
32463 return resultobj;
32464 fail:
32465 return NULL;
32466 }
32467
32468
32469 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32470 PyObject *resultobj = NULL;
32471 wxWindow *arg1 = (wxWindow *) 0 ;
32472 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32473 PyObject * obj0 = 0 ;
32474 PyObject * obj1 = 0 ;
32475 char *kwnames[] = {
32476 (char *) "self",(char *) "dropTarget", NULL
32477 };
32478
32479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32481 if (SWIG_arg_fail(1)) SWIG_fail;
32482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32483 if (SWIG_arg_fail(2)) SWIG_fail;
32484 {
32485 PyThreadState* __tstate = wxPyBeginAllowThreads();
32486 (arg1)->SetDropTarget(arg2);
32487
32488 wxPyEndAllowThreads(__tstate);
32489 if (PyErr_Occurred()) SWIG_fail;
32490 }
32491 Py_INCREF(Py_None); resultobj = Py_None;
32492 return resultobj;
32493 fail:
32494 return NULL;
32495 }
32496
32497
32498 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32499 PyObject *resultobj = NULL;
32500 wxWindow *arg1 = (wxWindow *) 0 ;
32501 wxPyDropTarget *result;
32502 PyObject * obj0 = 0 ;
32503 char *kwnames[] = {
32504 (char *) "self", NULL
32505 };
32506
32507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32509 if (SWIG_arg_fail(1)) SWIG_fail;
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32513
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32518 return resultobj;
32519 fail:
32520 return NULL;
32521 }
32522
32523
32524 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32525 PyObject *resultobj = NULL;
32526 wxWindow *arg1 = (wxWindow *) 0 ;
32527 bool arg2 ;
32528 PyObject * obj0 = 0 ;
32529 PyObject * obj1 = 0 ;
32530 char *kwnames[] = {
32531 (char *) "self",(char *) "accept", NULL
32532 };
32533
32534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32536 if (SWIG_arg_fail(1)) SWIG_fail;
32537 {
32538 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32539 if (SWIG_arg_fail(2)) SWIG_fail;
32540 }
32541 {
32542 PyThreadState* __tstate = wxPyBeginAllowThreads();
32543 wxWindow_DragAcceptFiles(arg1,arg2);
32544
32545 wxPyEndAllowThreads(__tstate);
32546 if (PyErr_Occurred()) SWIG_fail;
32547 }
32548 Py_INCREF(Py_None); resultobj = Py_None;
32549 return resultobj;
32550 fail:
32551 return NULL;
32552 }
32553
32554
32555 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32556 PyObject *resultobj = NULL;
32557 wxWindow *arg1 = (wxWindow *) 0 ;
32558 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32559 PyObject * obj0 = 0 ;
32560 PyObject * obj1 = 0 ;
32561 char *kwnames[] = {
32562 (char *) "self",(char *) "constraints", NULL
32563 };
32564
32565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32567 if (SWIG_arg_fail(1)) SWIG_fail;
32568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32569 if (SWIG_arg_fail(2)) SWIG_fail;
32570 {
32571 PyThreadState* __tstate = wxPyBeginAllowThreads();
32572 (arg1)->SetConstraints(arg2);
32573
32574 wxPyEndAllowThreads(__tstate);
32575 if (PyErr_Occurred()) SWIG_fail;
32576 }
32577 Py_INCREF(Py_None); resultobj = Py_None;
32578 return resultobj;
32579 fail:
32580 return NULL;
32581 }
32582
32583
32584 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32585 PyObject *resultobj = NULL;
32586 wxWindow *arg1 = (wxWindow *) 0 ;
32587 wxLayoutConstraints *result;
32588 PyObject * obj0 = 0 ;
32589 char *kwnames[] = {
32590 (char *) "self", NULL
32591 };
32592
32593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32595 if (SWIG_arg_fail(1)) SWIG_fail;
32596 {
32597 PyThreadState* __tstate = wxPyBeginAllowThreads();
32598 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32599
32600 wxPyEndAllowThreads(__tstate);
32601 if (PyErr_Occurred()) SWIG_fail;
32602 }
32603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32604 return resultobj;
32605 fail:
32606 return NULL;
32607 }
32608
32609
32610 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32611 PyObject *resultobj = NULL;
32612 wxWindow *arg1 = (wxWindow *) 0 ;
32613 bool arg2 ;
32614 PyObject * obj0 = 0 ;
32615 PyObject * obj1 = 0 ;
32616 char *kwnames[] = {
32617 (char *) "self",(char *) "autoLayout", NULL
32618 };
32619
32620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32622 if (SWIG_arg_fail(1)) SWIG_fail;
32623 {
32624 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32625 if (SWIG_arg_fail(2)) SWIG_fail;
32626 }
32627 {
32628 PyThreadState* __tstate = wxPyBeginAllowThreads();
32629 (arg1)->SetAutoLayout(arg2);
32630
32631 wxPyEndAllowThreads(__tstate);
32632 if (PyErr_Occurred()) SWIG_fail;
32633 }
32634 Py_INCREF(Py_None); resultobj = Py_None;
32635 return resultobj;
32636 fail:
32637 return NULL;
32638 }
32639
32640
32641 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32642 PyObject *resultobj = NULL;
32643 wxWindow *arg1 = (wxWindow *) 0 ;
32644 bool result;
32645 PyObject * obj0 = 0 ;
32646 char *kwnames[] = {
32647 (char *) "self", NULL
32648 };
32649
32650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32652 if (SWIG_arg_fail(1)) SWIG_fail;
32653 {
32654 PyThreadState* __tstate = wxPyBeginAllowThreads();
32655 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32656
32657 wxPyEndAllowThreads(__tstate);
32658 if (PyErr_Occurred()) SWIG_fail;
32659 }
32660 {
32661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32662 }
32663 return resultobj;
32664 fail:
32665 return NULL;
32666 }
32667
32668
32669 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32670 PyObject *resultobj = NULL;
32671 wxWindow *arg1 = (wxWindow *) 0 ;
32672 bool result;
32673 PyObject * obj0 = 0 ;
32674 char *kwnames[] = {
32675 (char *) "self", NULL
32676 };
32677
32678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32680 if (SWIG_arg_fail(1)) SWIG_fail;
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 result = (bool)(arg1)->Layout();
32684
32685 wxPyEndAllowThreads(__tstate);
32686 if (PyErr_Occurred()) SWIG_fail;
32687 }
32688 {
32689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32690 }
32691 return resultobj;
32692 fail:
32693 return NULL;
32694 }
32695
32696
32697 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32698 PyObject *resultobj = NULL;
32699 wxWindow *arg1 = (wxWindow *) 0 ;
32700 wxSizer *arg2 = (wxSizer *) 0 ;
32701 bool arg3 = (bool) true ;
32702 PyObject * obj0 = 0 ;
32703 PyObject * obj1 = 0 ;
32704 PyObject * obj2 = 0 ;
32705 char *kwnames[] = {
32706 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32707 };
32708
32709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32711 if (SWIG_arg_fail(1)) SWIG_fail;
32712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32713 if (SWIG_arg_fail(2)) SWIG_fail;
32714 if (obj2) {
32715 {
32716 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32717 if (SWIG_arg_fail(3)) SWIG_fail;
32718 }
32719 }
32720 {
32721 PyThreadState* __tstate = wxPyBeginAllowThreads();
32722 (arg1)->SetSizer(arg2,arg3);
32723
32724 wxPyEndAllowThreads(__tstate);
32725 if (PyErr_Occurred()) SWIG_fail;
32726 }
32727 Py_INCREF(Py_None); resultobj = Py_None;
32728 return resultobj;
32729 fail:
32730 return NULL;
32731 }
32732
32733
32734 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32735 PyObject *resultobj = NULL;
32736 wxWindow *arg1 = (wxWindow *) 0 ;
32737 wxSizer *arg2 = (wxSizer *) 0 ;
32738 bool arg3 = (bool) true ;
32739 PyObject * obj0 = 0 ;
32740 PyObject * obj1 = 0 ;
32741 PyObject * obj2 = 0 ;
32742 char *kwnames[] = {
32743 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32744 };
32745
32746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32748 if (SWIG_arg_fail(1)) SWIG_fail;
32749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32750 if (SWIG_arg_fail(2)) SWIG_fail;
32751 if (obj2) {
32752 {
32753 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32754 if (SWIG_arg_fail(3)) SWIG_fail;
32755 }
32756 }
32757 {
32758 PyThreadState* __tstate = wxPyBeginAllowThreads();
32759 (arg1)->SetSizerAndFit(arg2,arg3);
32760
32761 wxPyEndAllowThreads(__tstate);
32762 if (PyErr_Occurred()) SWIG_fail;
32763 }
32764 Py_INCREF(Py_None); resultobj = Py_None;
32765 return resultobj;
32766 fail:
32767 return NULL;
32768 }
32769
32770
32771 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32772 PyObject *resultobj = NULL;
32773 wxWindow *arg1 = (wxWindow *) 0 ;
32774 wxSizer *result;
32775 PyObject * obj0 = 0 ;
32776 char *kwnames[] = {
32777 (char *) "self", NULL
32778 };
32779
32780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32782 if (SWIG_arg_fail(1)) SWIG_fail;
32783 {
32784 PyThreadState* __tstate = wxPyBeginAllowThreads();
32785 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32786
32787 wxPyEndAllowThreads(__tstate);
32788 if (PyErr_Occurred()) SWIG_fail;
32789 }
32790 {
32791 resultobj = wxPyMake_wxObject(result, (bool)0);
32792 }
32793 return resultobj;
32794 fail:
32795 return NULL;
32796 }
32797
32798
32799 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32800 PyObject *resultobj = NULL;
32801 wxWindow *arg1 = (wxWindow *) 0 ;
32802 wxSizer *arg2 = (wxSizer *) 0 ;
32803 PyObject * obj0 = 0 ;
32804 PyObject * obj1 = 0 ;
32805 char *kwnames[] = {
32806 (char *) "self",(char *) "sizer", NULL
32807 };
32808
32809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32811 if (SWIG_arg_fail(1)) SWIG_fail;
32812 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32813 if (SWIG_arg_fail(2)) SWIG_fail;
32814 {
32815 PyThreadState* __tstate = wxPyBeginAllowThreads();
32816 (arg1)->SetContainingSizer(arg2);
32817
32818 wxPyEndAllowThreads(__tstate);
32819 if (PyErr_Occurred()) SWIG_fail;
32820 }
32821 Py_INCREF(Py_None); resultobj = Py_None;
32822 return resultobj;
32823 fail:
32824 return NULL;
32825 }
32826
32827
32828 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32829 PyObject *resultobj = NULL;
32830 wxWindow *arg1 = (wxWindow *) 0 ;
32831 wxSizer *result;
32832 PyObject * obj0 = 0 ;
32833 char *kwnames[] = {
32834 (char *) "self", NULL
32835 };
32836
32837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32839 if (SWIG_arg_fail(1)) SWIG_fail;
32840 {
32841 PyThreadState* __tstate = wxPyBeginAllowThreads();
32842 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32843
32844 wxPyEndAllowThreads(__tstate);
32845 if (PyErr_Occurred()) SWIG_fail;
32846 }
32847 {
32848 resultobj = wxPyMake_wxObject(result, (bool)0);
32849 }
32850 return resultobj;
32851 fail:
32852 return NULL;
32853 }
32854
32855
32856 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32857 PyObject *resultobj = NULL;
32858 wxWindow *arg1 = (wxWindow *) 0 ;
32859 PyObject * obj0 = 0 ;
32860 char *kwnames[] = {
32861 (char *) "self", NULL
32862 };
32863
32864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32866 if (SWIG_arg_fail(1)) SWIG_fail;
32867 {
32868 PyThreadState* __tstate = wxPyBeginAllowThreads();
32869 (arg1)->InheritAttributes();
32870
32871 wxPyEndAllowThreads(__tstate);
32872 if (PyErr_Occurred()) SWIG_fail;
32873 }
32874 Py_INCREF(Py_None); resultobj = Py_None;
32875 return resultobj;
32876 fail:
32877 return NULL;
32878 }
32879
32880
32881 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32882 PyObject *resultobj = NULL;
32883 wxWindow *arg1 = (wxWindow *) 0 ;
32884 bool result;
32885 PyObject * obj0 = 0 ;
32886 char *kwnames[] = {
32887 (char *) "self", NULL
32888 };
32889
32890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32892 if (SWIG_arg_fail(1)) SWIG_fail;
32893 {
32894 PyThreadState* __tstate = wxPyBeginAllowThreads();
32895 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32896
32897 wxPyEndAllowThreads(__tstate);
32898 if (PyErr_Occurred()) SWIG_fail;
32899 }
32900 {
32901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32902 }
32903 return resultobj;
32904 fail:
32905 return NULL;
32906 }
32907
32908
32909 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32910 PyObject *obj;
32911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32912 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32913 Py_INCREF(obj);
32914 return Py_BuildValue((char *)"");
32915 }
32916 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32917 PyObject *resultobj = NULL;
32918 long arg1 ;
32919 wxWindow *arg2 = (wxWindow *) NULL ;
32920 wxWindow *result;
32921 PyObject * obj0 = 0 ;
32922 PyObject * obj1 = 0 ;
32923 char *kwnames[] = {
32924 (char *) "id",(char *) "parent", NULL
32925 };
32926
32927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32928 {
32929 arg1 = static_cast<long >(SWIG_As_long(obj0));
32930 if (SWIG_arg_fail(1)) SWIG_fail;
32931 }
32932 if (obj1) {
32933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32934 if (SWIG_arg_fail(2)) SWIG_fail;
32935 }
32936 {
32937 if (!wxPyCheckForApp()) SWIG_fail;
32938 PyThreadState* __tstate = wxPyBeginAllowThreads();
32939 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32940
32941 wxPyEndAllowThreads(__tstate);
32942 if (PyErr_Occurred()) SWIG_fail;
32943 }
32944 {
32945 resultobj = wxPyMake_wxObject(result, 0);
32946 }
32947 return resultobj;
32948 fail:
32949 return NULL;
32950 }
32951
32952
32953 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32954 PyObject *resultobj = NULL;
32955 wxString *arg1 = 0 ;
32956 wxWindow *arg2 = (wxWindow *) NULL ;
32957 wxWindow *result;
32958 bool temp1 = false ;
32959 PyObject * obj0 = 0 ;
32960 PyObject * obj1 = 0 ;
32961 char *kwnames[] = {
32962 (char *) "name",(char *) "parent", NULL
32963 };
32964
32965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32966 {
32967 arg1 = wxString_in_helper(obj0);
32968 if (arg1 == NULL) SWIG_fail;
32969 temp1 = true;
32970 }
32971 if (obj1) {
32972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32973 if (SWIG_arg_fail(2)) SWIG_fail;
32974 }
32975 {
32976 if (!wxPyCheckForApp()) SWIG_fail;
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32979
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 {
32984 resultobj = wxPyMake_wxObject(result, 0);
32985 }
32986 {
32987 if (temp1)
32988 delete arg1;
32989 }
32990 return resultobj;
32991 fail:
32992 {
32993 if (temp1)
32994 delete arg1;
32995 }
32996 return NULL;
32997 }
32998
32999
33000 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33001 PyObject *resultobj = NULL;
33002 wxString *arg1 = 0 ;
33003 wxWindow *arg2 = (wxWindow *) NULL ;
33004 wxWindow *result;
33005 bool temp1 = false ;
33006 PyObject * obj0 = 0 ;
33007 PyObject * obj1 = 0 ;
33008 char *kwnames[] = {
33009 (char *) "label",(char *) "parent", NULL
33010 };
33011
33012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33013 {
33014 arg1 = wxString_in_helper(obj0);
33015 if (arg1 == NULL) SWIG_fail;
33016 temp1 = true;
33017 }
33018 if (obj1) {
33019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33020 if (SWIG_arg_fail(2)) SWIG_fail;
33021 }
33022 {
33023 if (!wxPyCheckForApp()) SWIG_fail;
33024 PyThreadState* __tstate = wxPyBeginAllowThreads();
33025 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33026
33027 wxPyEndAllowThreads(__tstate);
33028 if (PyErr_Occurred()) SWIG_fail;
33029 }
33030 {
33031 resultobj = wxPyMake_wxObject(result, 0);
33032 }
33033 {
33034 if (temp1)
33035 delete arg1;
33036 }
33037 return resultobj;
33038 fail:
33039 {
33040 if (temp1)
33041 delete arg1;
33042 }
33043 return NULL;
33044 }
33045
33046
33047 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33048 PyObject *resultobj = NULL;
33049 wxWindow *arg1 = (wxWindow *) 0 ;
33050 unsigned long arg2 ;
33051 wxWindow *result;
33052 PyObject * obj0 = 0 ;
33053 PyObject * obj1 = 0 ;
33054 char *kwnames[] = {
33055 (char *) "parent",(char *) "_hWnd", NULL
33056 };
33057
33058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33060 if (SWIG_arg_fail(1)) SWIG_fail;
33061 {
33062 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33063 if (SWIG_arg_fail(2)) SWIG_fail;
33064 }
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33068
33069 wxPyEndAllowThreads(__tstate);
33070 if (PyErr_Occurred()) SWIG_fail;
33071 }
33072 {
33073 resultobj = wxPyMake_wxObject(result, 0);
33074 }
33075 return resultobj;
33076 fail:
33077 return NULL;
33078 }
33079
33080
33081 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33082 PyObject *resultobj = NULL;
33083 PyObject *result;
33084 char *kwnames[] = {
33085 NULL
33086 };
33087
33088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33089 {
33090 PyThreadState* __tstate = wxPyBeginAllowThreads();
33091 result = (PyObject *)GetTopLevelWindows();
33092
33093 wxPyEndAllowThreads(__tstate);
33094 if (PyErr_Occurred()) SWIG_fail;
33095 }
33096 resultobj = result;
33097 return resultobj;
33098 fail:
33099 return NULL;
33100 }
33101
33102
33103 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33104 PyObject *resultobj = NULL;
33105 wxValidator *result;
33106 char *kwnames[] = {
33107 NULL
33108 };
33109
33110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33111 {
33112 PyThreadState* __tstate = wxPyBeginAllowThreads();
33113 result = (wxValidator *)new wxValidator();
33114
33115 wxPyEndAllowThreads(__tstate);
33116 if (PyErr_Occurred()) SWIG_fail;
33117 }
33118 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33119 return resultobj;
33120 fail:
33121 return NULL;
33122 }
33123
33124
33125 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33126 PyObject *resultobj = NULL;
33127 wxValidator *arg1 = (wxValidator *) 0 ;
33128 wxValidator *result;
33129 PyObject * obj0 = 0 ;
33130 char *kwnames[] = {
33131 (char *) "self", NULL
33132 };
33133
33134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33136 if (SWIG_arg_fail(1)) SWIG_fail;
33137 {
33138 PyThreadState* __tstate = wxPyBeginAllowThreads();
33139 result = (wxValidator *)(arg1)->Clone();
33140
33141 wxPyEndAllowThreads(__tstate);
33142 if (PyErr_Occurred()) SWIG_fail;
33143 }
33144 {
33145 resultobj = wxPyMake_wxObject(result, 0);
33146 }
33147 return resultobj;
33148 fail:
33149 return NULL;
33150 }
33151
33152
33153 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33154 PyObject *resultobj = NULL;
33155 wxValidator *arg1 = (wxValidator *) 0 ;
33156 wxWindow *arg2 = (wxWindow *) 0 ;
33157 bool result;
33158 PyObject * obj0 = 0 ;
33159 PyObject * obj1 = 0 ;
33160 char *kwnames[] = {
33161 (char *) "self",(char *) "parent", NULL
33162 };
33163
33164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33166 if (SWIG_arg_fail(1)) SWIG_fail;
33167 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33168 if (SWIG_arg_fail(2)) SWIG_fail;
33169 {
33170 PyThreadState* __tstate = wxPyBeginAllowThreads();
33171 result = (bool)(arg1)->Validate(arg2);
33172
33173 wxPyEndAllowThreads(__tstate);
33174 if (PyErr_Occurred()) SWIG_fail;
33175 }
33176 {
33177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33178 }
33179 return resultobj;
33180 fail:
33181 return NULL;
33182 }
33183
33184
33185 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33186 PyObject *resultobj = NULL;
33187 wxValidator *arg1 = (wxValidator *) 0 ;
33188 bool result;
33189 PyObject * obj0 = 0 ;
33190 char *kwnames[] = {
33191 (char *) "self", NULL
33192 };
33193
33194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33196 if (SWIG_arg_fail(1)) SWIG_fail;
33197 {
33198 PyThreadState* __tstate = wxPyBeginAllowThreads();
33199 result = (bool)(arg1)->TransferToWindow();
33200
33201 wxPyEndAllowThreads(__tstate);
33202 if (PyErr_Occurred()) SWIG_fail;
33203 }
33204 {
33205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33206 }
33207 return resultobj;
33208 fail:
33209 return NULL;
33210 }
33211
33212
33213 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33214 PyObject *resultobj = NULL;
33215 wxValidator *arg1 = (wxValidator *) 0 ;
33216 bool result;
33217 PyObject * obj0 = 0 ;
33218 char *kwnames[] = {
33219 (char *) "self", NULL
33220 };
33221
33222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33224 if (SWIG_arg_fail(1)) SWIG_fail;
33225 {
33226 PyThreadState* __tstate = wxPyBeginAllowThreads();
33227 result = (bool)(arg1)->TransferFromWindow();
33228
33229 wxPyEndAllowThreads(__tstate);
33230 if (PyErr_Occurred()) SWIG_fail;
33231 }
33232 {
33233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33234 }
33235 return resultobj;
33236 fail:
33237 return NULL;
33238 }
33239
33240
33241 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33242 PyObject *resultobj = NULL;
33243 wxValidator *arg1 = (wxValidator *) 0 ;
33244 wxWindow *result;
33245 PyObject * obj0 = 0 ;
33246 char *kwnames[] = {
33247 (char *) "self", NULL
33248 };
33249
33250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33252 if (SWIG_arg_fail(1)) SWIG_fail;
33253 {
33254 PyThreadState* __tstate = wxPyBeginAllowThreads();
33255 result = (wxWindow *)(arg1)->GetWindow();
33256
33257 wxPyEndAllowThreads(__tstate);
33258 if (PyErr_Occurred()) SWIG_fail;
33259 }
33260 {
33261 resultobj = wxPyMake_wxObject(result, 0);
33262 }
33263 return resultobj;
33264 fail:
33265 return NULL;
33266 }
33267
33268
33269 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33270 PyObject *resultobj = NULL;
33271 wxValidator *arg1 = (wxValidator *) 0 ;
33272 wxWindow *arg2 = (wxWindow *) 0 ;
33273 PyObject * obj0 = 0 ;
33274 PyObject * obj1 = 0 ;
33275 char *kwnames[] = {
33276 (char *) "self",(char *) "window", NULL
33277 };
33278
33279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33281 if (SWIG_arg_fail(1)) SWIG_fail;
33282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33283 if (SWIG_arg_fail(2)) SWIG_fail;
33284 {
33285 PyThreadState* __tstate = wxPyBeginAllowThreads();
33286 (arg1)->SetWindow(arg2);
33287
33288 wxPyEndAllowThreads(__tstate);
33289 if (PyErr_Occurred()) SWIG_fail;
33290 }
33291 Py_INCREF(Py_None); resultobj = Py_None;
33292 return resultobj;
33293 fail:
33294 return NULL;
33295 }
33296
33297
33298 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33299 PyObject *resultobj = NULL;
33300 bool result;
33301 char *kwnames[] = {
33302 NULL
33303 };
33304
33305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33306 {
33307 PyThreadState* __tstate = wxPyBeginAllowThreads();
33308 result = (bool)wxValidator::IsSilent();
33309
33310 wxPyEndAllowThreads(__tstate);
33311 if (PyErr_Occurred()) SWIG_fail;
33312 }
33313 {
33314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33315 }
33316 return resultobj;
33317 fail:
33318 return NULL;
33319 }
33320
33321
33322 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33323 PyObject *resultobj = NULL;
33324 int arg1 = (int) true ;
33325 PyObject * obj0 = 0 ;
33326 char *kwnames[] = {
33327 (char *) "doIt", NULL
33328 };
33329
33330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33331 if (obj0) {
33332 {
33333 arg1 = static_cast<int >(SWIG_As_int(obj0));
33334 if (SWIG_arg_fail(1)) SWIG_fail;
33335 }
33336 }
33337 {
33338 PyThreadState* __tstate = wxPyBeginAllowThreads();
33339 wxValidator::SetBellOnError(arg1);
33340
33341 wxPyEndAllowThreads(__tstate);
33342 if (PyErr_Occurred()) SWIG_fail;
33343 }
33344 Py_INCREF(Py_None); resultobj = Py_None;
33345 return resultobj;
33346 fail:
33347 return NULL;
33348 }
33349
33350
33351 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33352 PyObject *obj;
33353 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33354 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33355 Py_INCREF(obj);
33356 return Py_BuildValue((char *)"");
33357 }
33358 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33359 PyObject *resultobj = NULL;
33360 wxPyValidator *result;
33361 char *kwnames[] = {
33362 NULL
33363 };
33364
33365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33366 {
33367 PyThreadState* __tstate = wxPyBeginAllowThreads();
33368 result = (wxPyValidator *)new wxPyValidator();
33369
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33381 PyObject *resultobj = NULL;
33382 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33383 PyObject *arg2 = (PyObject *) 0 ;
33384 PyObject *arg3 = (PyObject *) 0 ;
33385 int arg4 = (int) true ;
33386 PyObject * obj0 = 0 ;
33387 PyObject * obj1 = 0 ;
33388 PyObject * obj2 = 0 ;
33389 PyObject * obj3 = 0 ;
33390 char *kwnames[] = {
33391 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33392 };
33393
33394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33396 if (SWIG_arg_fail(1)) SWIG_fail;
33397 arg2 = obj1;
33398 arg3 = obj2;
33399 if (obj3) {
33400 {
33401 arg4 = static_cast<int >(SWIG_As_int(obj3));
33402 if (SWIG_arg_fail(4)) SWIG_fail;
33403 }
33404 }
33405 {
33406 PyThreadState* __tstate = wxPyBeginAllowThreads();
33407 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33408
33409 wxPyEndAllowThreads(__tstate);
33410 if (PyErr_Occurred()) SWIG_fail;
33411 }
33412 Py_INCREF(Py_None); resultobj = Py_None;
33413 return resultobj;
33414 fail:
33415 return NULL;
33416 }
33417
33418
33419 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33420 PyObject *obj;
33421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33422 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33423 Py_INCREF(obj);
33424 return Py_BuildValue((char *)"");
33425 }
33426 static int _wrap_DefaultValidator_set(PyObject *) {
33427 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33428 return 1;
33429 }
33430
33431
33432 static PyObject *_wrap_DefaultValidator_get(void) {
33433 PyObject *pyobj = NULL;
33434
33435 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33436 return pyobj;
33437 }
33438
33439
33440 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33441 PyObject *resultobj = NULL;
33442 wxString const &arg1_defvalue = wxPyEmptyString ;
33443 wxString *arg1 = (wxString *) &arg1_defvalue ;
33444 long arg2 = (long) 0 ;
33445 wxMenu *result;
33446 bool temp1 = false ;
33447 PyObject * obj0 = 0 ;
33448 PyObject * obj1 = 0 ;
33449 char *kwnames[] = {
33450 (char *) "title",(char *) "style", NULL
33451 };
33452
33453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33454 if (obj0) {
33455 {
33456 arg1 = wxString_in_helper(obj0);
33457 if (arg1 == NULL) SWIG_fail;
33458 temp1 = true;
33459 }
33460 }
33461 if (obj1) {
33462 {
33463 arg2 = static_cast<long >(SWIG_As_long(obj1));
33464 if (SWIG_arg_fail(2)) SWIG_fail;
33465 }
33466 }
33467 {
33468 if (!wxPyCheckForApp()) SWIG_fail;
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33471
33472 wxPyEndAllowThreads(__tstate);
33473 if (PyErr_Occurred()) SWIG_fail;
33474 }
33475 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33476 {
33477 if (temp1)
33478 delete arg1;
33479 }
33480 return resultobj;
33481 fail:
33482 {
33483 if (temp1)
33484 delete arg1;
33485 }
33486 return NULL;
33487 }
33488
33489
33490 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33491 PyObject *resultobj = NULL;
33492 wxMenu *arg1 = (wxMenu *) 0 ;
33493 int arg2 ;
33494 wxString *arg3 = 0 ;
33495 wxString const &arg4_defvalue = wxPyEmptyString ;
33496 wxString *arg4 = (wxString *) &arg4_defvalue ;
33497 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33498 wxMenuItem *result;
33499 bool temp3 = false ;
33500 bool temp4 = false ;
33501 PyObject * obj0 = 0 ;
33502 PyObject * obj1 = 0 ;
33503 PyObject * obj2 = 0 ;
33504 PyObject * obj3 = 0 ;
33505 PyObject * obj4 = 0 ;
33506 char *kwnames[] = {
33507 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33508 };
33509
33510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33512 if (SWIG_arg_fail(1)) SWIG_fail;
33513 {
33514 arg2 = static_cast<int >(SWIG_As_int(obj1));
33515 if (SWIG_arg_fail(2)) SWIG_fail;
33516 }
33517 {
33518 arg3 = wxString_in_helper(obj2);
33519 if (arg3 == NULL) SWIG_fail;
33520 temp3 = true;
33521 }
33522 if (obj3) {
33523 {
33524 arg4 = wxString_in_helper(obj3);
33525 if (arg4 == NULL) SWIG_fail;
33526 temp4 = true;
33527 }
33528 }
33529 if (obj4) {
33530 {
33531 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33532 if (SWIG_arg_fail(5)) SWIG_fail;
33533 }
33534 }
33535 {
33536 PyThreadState* __tstate = wxPyBeginAllowThreads();
33537 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33538
33539 wxPyEndAllowThreads(__tstate);
33540 if (PyErr_Occurred()) SWIG_fail;
33541 }
33542 {
33543 resultobj = wxPyMake_wxObject(result, (bool)0);
33544 }
33545 {
33546 if (temp3)
33547 delete arg3;
33548 }
33549 {
33550 if (temp4)
33551 delete arg4;
33552 }
33553 return resultobj;
33554 fail:
33555 {
33556 if (temp3)
33557 delete arg3;
33558 }
33559 {
33560 if (temp4)
33561 delete arg4;
33562 }
33563 return NULL;
33564 }
33565
33566
33567 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33568 PyObject *resultobj = NULL;
33569 wxMenu *arg1 = (wxMenu *) 0 ;
33570 wxMenuItem *result;
33571 PyObject * obj0 = 0 ;
33572 char *kwnames[] = {
33573 (char *) "self", NULL
33574 };
33575
33576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33578 if (SWIG_arg_fail(1)) SWIG_fail;
33579 {
33580 PyThreadState* __tstate = wxPyBeginAllowThreads();
33581 result = (wxMenuItem *)(arg1)->AppendSeparator();
33582
33583 wxPyEndAllowThreads(__tstate);
33584 if (PyErr_Occurred()) SWIG_fail;
33585 }
33586 {
33587 resultobj = wxPyMake_wxObject(result, (bool)0);
33588 }
33589 return resultobj;
33590 fail:
33591 return NULL;
33592 }
33593
33594
33595 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33596 PyObject *resultobj = NULL;
33597 wxMenu *arg1 = (wxMenu *) 0 ;
33598 int arg2 ;
33599 wxString *arg3 = 0 ;
33600 wxString const &arg4_defvalue = wxPyEmptyString ;
33601 wxString *arg4 = (wxString *) &arg4_defvalue ;
33602 wxMenuItem *result;
33603 bool temp3 = false ;
33604 bool temp4 = false ;
33605 PyObject * obj0 = 0 ;
33606 PyObject * obj1 = 0 ;
33607 PyObject * obj2 = 0 ;
33608 PyObject * obj3 = 0 ;
33609 char *kwnames[] = {
33610 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33611 };
33612
33613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33615 if (SWIG_arg_fail(1)) SWIG_fail;
33616 {
33617 arg2 = static_cast<int >(SWIG_As_int(obj1));
33618 if (SWIG_arg_fail(2)) SWIG_fail;
33619 }
33620 {
33621 arg3 = wxString_in_helper(obj2);
33622 if (arg3 == NULL) SWIG_fail;
33623 temp3 = true;
33624 }
33625 if (obj3) {
33626 {
33627 arg4 = wxString_in_helper(obj3);
33628 if (arg4 == NULL) SWIG_fail;
33629 temp4 = true;
33630 }
33631 }
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33635
33636 wxPyEndAllowThreads(__tstate);
33637 if (PyErr_Occurred()) SWIG_fail;
33638 }
33639 {
33640 resultobj = wxPyMake_wxObject(result, (bool)0);
33641 }
33642 {
33643 if (temp3)
33644 delete arg3;
33645 }
33646 {
33647 if (temp4)
33648 delete arg4;
33649 }
33650 return resultobj;
33651 fail:
33652 {
33653 if (temp3)
33654 delete arg3;
33655 }
33656 {
33657 if (temp4)
33658 delete arg4;
33659 }
33660 return NULL;
33661 }
33662
33663
33664 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33665 PyObject *resultobj = NULL;
33666 wxMenu *arg1 = (wxMenu *) 0 ;
33667 int arg2 ;
33668 wxString *arg3 = 0 ;
33669 wxString const &arg4_defvalue = wxPyEmptyString ;
33670 wxString *arg4 = (wxString *) &arg4_defvalue ;
33671 wxMenuItem *result;
33672 bool temp3 = false ;
33673 bool temp4 = false ;
33674 PyObject * obj0 = 0 ;
33675 PyObject * obj1 = 0 ;
33676 PyObject * obj2 = 0 ;
33677 PyObject * obj3 = 0 ;
33678 char *kwnames[] = {
33679 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33680 };
33681
33682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33684 if (SWIG_arg_fail(1)) SWIG_fail;
33685 {
33686 arg2 = static_cast<int >(SWIG_As_int(obj1));
33687 if (SWIG_arg_fail(2)) SWIG_fail;
33688 }
33689 {
33690 arg3 = wxString_in_helper(obj2);
33691 if (arg3 == NULL) SWIG_fail;
33692 temp3 = true;
33693 }
33694 if (obj3) {
33695 {
33696 arg4 = wxString_in_helper(obj3);
33697 if (arg4 == NULL) SWIG_fail;
33698 temp4 = true;
33699 }
33700 }
33701 {
33702 PyThreadState* __tstate = wxPyBeginAllowThreads();
33703 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33704
33705 wxPyEndAllowThreads(__tstate);
33706 if (PyErr_Occurred()) SWIG_fail;
33707 }
33708 {
33709 resultobj = wxPyMake_wxObject(result, (bool)0);
33710 }
33711 {
33712 if (temp3)
33713 delete arg3;
33714 }
33715 {
33716 if (temp4)
33717 delete arg4;
33718 }
33719 return resultobj;
33720 fail:
33721 {
33722 if (temp3)
33723 delete arg3;
33724 }
33725 {
33726 if (temp4)
33727 delete arg4;
33728 }
33729 return NULL;
33730 }
33731
33732
33733 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33734 PyObject *resultobj = NULL;
33735 wxMenu *arg1 = (wxMenu *) 0 ;
33736 int arg2 ;
33737 wxString *arg3 = 0 ;
33738 wxMenu *arg4 = (wxMenu *) 0 ;
33739 wxString const &arg5_defvalue = wxPyEmptyString ;
33740 wxString *arg5 = (wxString *) &arg5_defvalue ;
33741 wxMenuItem *result;
33742 bool temp3 = false ;
33743 bool temp5 = false ;
33744 PyObject * obj0 = 0 ;
33745 PyObject * obj1 = 0 ;
33746 PyObject * obj2 = 0 ;
33747 PyObject * obj3 = 0 ;
33748 PyObject * obj4 = 0 ;
33749 char *kwnames[] = {
33750 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33751 };
33752
33753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33755 if (SWIG_arg_fail(1)) SWIG_fail;
33756 {
33757 arg2 = static_cast<int >(SWIG_As_int(obj1));
33758 if (SWIG_arg_fail(2)) SWIG_fail;
33759 }
33760 {
33761 arg3 = wxString_in_helper(obj2);
33762 if (arg3 == NULL) SWIG_fail;
33763 temp3 = true;
33764 }
33765 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33766 if (SWIG_arg_fail(4)) SWIG_fail;
33767 if (obj4) {
33768 {
33769 arg5 = wxString_in_helper(obj4);
33770 if (arg5 == NULL) SWIG_fail;
33771 temp5 = true;
33772 }
33773 }
33774 {
33775 PyThreadState* __tstate = wxPyBeginAllowThreads();
33776 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33777
33778 wxPyEndAllowThreads(__tstate);
33779 if (PyErr_Occurred()) SWIG_fail;
33780 }
33781 {
33782 resultobj = wxPyMake_wxObject(result, (bool)0);
33783 }
33784 {
33785 if (temp3)
33786 delete arg3;
33787 }
33788 {
33789 if (temp5)
33790 delete arg5;
33791 }
33792 return resultobj;
33793 fail:
33794 {
33795 if (temp3)
33796 delete arg3;
33797 }
33798 {
33799 if (temp5)
33800 delete arg5;
33801 }
33802 return NULL;
33803 }
33804
33805
33806 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33807 PyObject *resultobj = NULL;
33808 wxMenu *arg1 = (wxMenu *) 0 ;
33809 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33810 wxMenuItem *result;
33811 PyObject * obj0 = 0 ;
33812 PyObject * obj1 = 0 ;
33813 char *kwnames[] = {
33814 (char *) "self",(char *) "item", NULL
33815 };
33816
33817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33819 if (SWIG_arg_fail(1)) SWIG_fail;
33820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33821 if (SWIG_arg_fail(2)) SWIG_fail;
33822 {
33823 PyThreadState* __tstate = wxPyBeginAllowThreads();
33824 result = (wxMenuItem *)(arg1)->Append(arg2);
33825
33826 wxPyEndAllowThreads(__tstate);
33827 if (PyErr_Occurred()) SWIG_fail;
33828 }
33829 {
33830 resultobj = wxPyMake_wxObject(result, (bool)0);
33831 }
33832 return resultobj;
33833 fail:
33834 return NULL;
33835 }
33836
33837
33838 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33839 PyObject *resultobj = NULL;
33840 wxMenu *arg1 = (wxMenu *) 0 ;
33841 PyObject * obj0 = 0 ;
33842 char *kwnames[] = {
33843 (char *) "self", NULL
33844 };
33845
33846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33848 if (SWIG_arg_fail(1)) SWIG_fail;
33849 {
33850 PyThreadState* __tstate = wxPyBeginAllowThreads();
33851 (arg1)->Break();
33852
33853 wxPyEndAllowThreads(__tstate);
33854 if (PyErr_Occurred()) SWIG_fail;
33855 }
33856 Py_INCREF(Py_None); resultobj = Py_None;
33857 return resultobj;
33858 fail:
33859 return NULL;
33860 }
33861
33862
33863 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33864 PyObject *resultobj = NULL;
33865 wxMenu *arg1 = (wxMenu *) 0 ;
33866 size_t arg2 ;
33867 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33868 wxMenuItem *result;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 PyObject * obj2 = 0 ;
33872 char *kwnames[] = {
33873 (char *) "self",(char *) "pos",(char *) "item", NULL
33874 };
33875
33876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33878 if (SWIG_arg_fail(1)) SWIG_fail;
33879 {
33880 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33881 if (SWIG_arg_fail(2)) SWIG_fail;
33882 }
33883 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33884 if (SWIG_arg_fail(3)) SWIG_fail;
33885 {
33886 PyThreadState* __tstate = wxPyBeginAllowThreads();
33887 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33888
33889 wxPyEndAllowThreads(__tstate);
33890 if (PyErr_Occurred()) SWIG_fail;
33891 }
33892 {
33893 resultobj = wxPyMake_wxObject(result, (bool)0);
33894 }
33895 return resultobj;
33896 fail:
33897 return NULL;
33898 }
33899
33900
33901 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33902 PyObject *resultobj = NULL;
33903 wxMenu *arg1 = (wxMenu *) 0 ;
33904 size_t arg2 ;
33905 int arg3 ;
33906 wxString *arg4 = 0 ;
33907 wxString const &arg5_defvalue = wxPyEmptyString ;
33908 wxString *arg5 = (wxString *) &arg5_defvalue ;
33909 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33910 wxMenuItem *result;
33911 bool temp4 = false ;
33912 bool temp5 = false ;
33913 PyObject * obj0 = 0 ;
33914 PyObject * obj1 = 0 ;
33915 PyObject * obj2 = 0 ;
33916 PyObject * obj3 = 0 ;
33917 PyObject * obj4 = 0 ;
33918 PyObject * obj5 = 0 ;
33919 char *kwnames[] = {
33920 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33921 };
33922
33923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33925 if (SWIG_arg_fail(1)) SWIG_fail;
33926 {
33927 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33928 if (SWIG_arg_fail(2)) SWIG_fail;
33929 }
33930 {
33931 arg3 = static_cast<int >(SWIG_As_int(obj2));
33932 if (SWIG_arg_fail(3)) SWIG_fail;
33933 }
33934 {
33935 arg4 = wxString_in_helper(obj3);
33936 if (arg4 == NULL) SWIG_fail;
33937 temp4 = true;
33938 }
33939 if (obj4) {
33940 {
33941 arg5 = wxString_in_helper(obj4);
33942 if (arg5 == NULL) SWIG_fail;
33943 temp5 = true;
33944 }
33945 }
33946 if (obj5) {
33947 {
33948 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
33949 if (SWIG_arg_fail(6)) SWIG_fail;
33950 }
33951 }
33952 {
33953 PyThreadState* __tstate = wxPyBeginAllowThreads();
33954 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
33955
33956 wxPyEndAllowThreads(__tstate);
33957 if (PyErr_Occurred()) SWIG_fail;
33958 }
33959 {
33960 resultobj = wxPyMake_wxObject(result, (bool)0);
33961 }
33962 {
33963 if (temp4)
33964 delete arg4;
33965 }
33966 {
33967 if (temp5)
33968 delete arg5;
33969 }
33970 return resultobj;
33971 fail:
33972 {
33973 if (temp4)
33974 delete arg4;
33975 }
33976 {
33977 if (temp5)
33978 delete arg5;
33979 }
33980 return NULL;
33981 }
33982
33983
33984 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33985 PyObject *resultobj = NULL;
33986 wxMenu *arg1 = (wxMenu *) 0 ;
33987 size_t arg2 ;
33988 wxMenuItem *result;
33989 PyObject * obj0 = 0 ;
33990 PyObject * obj1 = 0 ;
33991 char *kwnames[] = {
33992 (char *) "self",(char *) "pos", NULL
33993 };
33994
33995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33997 if (SWIG_arg_fail(1)) SWIG_fail;
33998 {
33999 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34000 if (SWIG_arg_fail(2)) SWIG_fail;
34001 }
34002 {
34003 PyThreadState* __tstate = wxPyBeginAllowThreads();
34004 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
34005
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 {
34010 resultobj = wxPyMake_wxObject(result, (bool)0);
34011 }
34012 return resultobj;
34013 fail:
34014 return NULL;
34015 }
34016
34017
34018 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34019 PyObject *resultobj = NULL;
34020 wxMenu *arg1 = (wxMenu *) 0 ;
34021 size_t arg2 ;
34022 int arg3 ;
34023 wxString *arg4 = 0 ;
34024 wxString const &arg5_defvalue = wxPyEmptyString ;
34025 wxString *arg5 = (wxString *) &arg5_defvalue ;
34026 wxMenuItem *result;
34027 bool temp4 = false ;
34028 bool temp5 = false ;
34029 PyObject * obj0 = 0 ;
34030 PyObject * obj1 = 0 ;
34031 PyObject * obj2 = 0 ;
34032 PyObject * obj3 = 0 ;
34033 PyObject * obj4 = 0 ;
34034 char *kwnames[] = {
34035 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34036 };
34037
34038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34040 if (SWIG_arg_fail(1)) SWIG_fail;
34041 {
34042 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34043 if (SWIG_arg_fail(2)) SWIG_fail;
34044 }
34045 {
34046 arg3 = static_cast<int >(SWIG_As_int(obj2));
34047 if (SWIG_arg_fail(3)) SWIG_fail;
34048 }
34049 {
34050 arg4 = wxString_in_helper(obj3);
34051 if (arg4 == NULL) SWIG_fail;
34052 temp4 = true;
34053 }
34054 if (obj4) {
34055 {
34056 arg5 = wxString_in_helper(obj4);
34057 if (arg5 == NULL) SWIG_fail;
34058 temp5 = true;
34059 }
34060 }
34061 {
34062 PyThreadState* __tstate = wxPyBeginAllowThreads();
34063 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34064
34065 wxPyEndAllowThreads(__tstate);
34066 if (PyErr_Occurred()) SWIG_fail;
34067 }
34068 {
34069 resultobj = wxPyMake_wxObject(result, (bool)0);
34070 }
34071 {
34072 if (temp4)
34073 delete arg4;
34074 }
34075 {
34076 if (temp5)
34077 delete arg5;
34078 }
34079 return resultobj;
34080 fail:
34081 {
34082 if (temp4)
34083 delete arg4;
34084 }
34085 {
34086 if (temp5)
34087 delete arg5;
34088 }
34089 return NULL;
34090 }
34091
34092
34093 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj = NULL;
34095 wxMenu *arg1 = (wxMenu *) 0 ;
34096 size_t arg2 ;
34097 int arg3 ;
34098 wxString *arg4 = 0 ;
34099 wxString const &arg5_defvalue = wxPyEmptyString ;
34100 wxString *arg5 = (wxString *) &arg5_defvalue ;
34101 wxMenuItem *result;
34102 bool temp4 = false ;
34103 bool temp5 = false ;
34104 PyObject * obj0 = 0 ;
34105 PyObject * obj1 = 0 ;
34106 PyObject * obj2 = 0 ;
34107 PyObject * obj3 = 0 ;
34108 PyObject * obj4 = 0 ;
34109 char *kwnames[] = {
34110 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34111 };
34112
34113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34115 if (SWIG_arg_fail(1)) SWIG_fail;
34116 {
34117 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34118 if (SWIG_arg_fail(2)) SWIG_fail;
34119 }
34120 {
34121 arg3 = static_cast<int >(SWIG_As_int(obj2));
34122 if (SWIG_arg_fail(3)) SWIG_fail;
34123 }
34124 {
34125 arg4 = wxString_in_helper(obj3);
34126 if (arg4 == NULL) SWIG_fail;
34127 temp4 = true;
34128 }
34129 if (obj4) {
34130 {
34131 arg5 = wxString_in_helper(obj4);
34132 if (arg5 == NULL) SWIG_fail;
34133 temp5 = true;
34134 }
34135 }
34136 {
34137 PyThreadState* __tstate = wxPyBeginAllowThreads();
34138 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34139
34140 wxPyEndAllowThreads(__tstate);
34141 if (PyErr_Occurred()) SWIG_fail;
34142 }
34143 {
34144 resultobj = wxPyMake_wxObject(result, (bool)0);
34145 }
34146 {
34147 if (temp4)
34148 delete arg4;
34149 }
34150 {
34151 if (temp5)
34152 delete arg5;
34153 }
34154 return resultobj;
34155 fail:
34156 {
34157 if (temp4)
34158 delete arg4;
34159 }
34160 {
34161 if (temp5)
34162 delete arg5;
34163 }
34164 return NULL;
34165 }
34166
34167
34168 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34169 PyObject *resultobj = NULL;
34170 wxMenu *arg1 = (wxMenu *) 0 ;
34171 size_t arg2 ;
34172 int arg3 ;
34173 wxString *arg4 = 0 ;
34174 wxMenu *arg5 = (wxMenu *) 0 ;
34175 wxString const &arg6_defvalue = wxPyEmptyString ;
34176 wxString *arg6 = (wxString *) &arg6_defvalue ;
34177 wxMenuItem *result;
34178 bool temp4 = false ;
34179 bool temp6 = false ;
34180 PyObject * obj0 = 0 ;
34181 PyObject * obj1 = 0 ;
34182 PyObject * obj2 = 0 ;
34183 PyObject * obj3 = 0 ;
34184 PyObject * obj4 = 0 ;
34185 PyObject * obj5 = 0 ;
34186 char *kwnames[] = {
34187 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34188 };
34189
34190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34192 if (SWIG_arg_fail(1)) SWIG_fail;
34193 {
34194 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34195 if (SWIG_arg_fail(2)) SWIG_fail;
34196 }
34197 {
34198 arg3 = static_cast<int >(SWIG_As_int(obj2));
34199 if (SWIG_arg_fail(3)) SWIG_fail;
34200 }
34201 {
34202 arg4 = wxString_in_helper(obj3);
34203 if (arg4 == NULL) SWIG_fail;
34204 temp4 = true;
34205 }
34206 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34207 if (SWIG_arg_fail(5)) SWIG_fail;
34208 if (obj5) {
34209 {
34210 arg6 = wxString_in_helper(obj5);
34211 if (arg6 == NULL) SWIG_fail;
34212 temp6 = true;
34213 }
34214 }
34215 {
34216 PyThreadState* __tstate = wxPyBeginAllowThreads();
34217 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34218
34219 wxPyEndAllowThreads(__tstate);
34220 if (PyErr_Occurred()) SWIG_fail;
34221 }
34222 {
34223 resultobj = wxPyMake_wxObject(result, (bool)0);
34224 }
34225 {
34226 if (temp4)
34227 delete arg4;
34228 }
34229 {
34230 if (temp6)
34231 delete arg6;
34232 }
34233 return resultobj;
34234 fail:
34235 {
34236 if (temp4)
34237 delete arg4;
34238 }
34239 {
34240 if (temp6)
34241 delete arg6;
34242 }
34243 return NULL;
34244 }
34245
34246
34247 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34248 PyObject *resultobj = NULL;
34249 wxMenu *arg1 = (wxMenu *) 0 ;
34250 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34251 wxMenuItem *result;
34252 PyObject * obj0 = 0 ;
34253 PyObject * obj1 = 0 ;
34254 char *kwnames[] = {
34255 (char *) "self",(char *) "item", NULL
34256 };
34257
34258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34260 if (SWIG_arg_fail(1)) SWIG_fail;
34261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34262 if (SWIG_arg_fail(2)) SWIG_fail;
34263 {
34264 PyThreadState* __tstate = wxPyBeginAllowThreads();
34265 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34266
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 {
34271 resultobj = wxPyMake_wxObject(result, (bool)0);
34272 }
34273 return resultobj;
34274 fail:
34275 return NULL;
34276 }
34277
34278
34279 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34280 PyObject *resultobj = NULL;
34281 wxMenu *arg1 = (wxMenu *) 0 ;
34282 int arg2 ;
34283 wxString *arg3 = 0 ;
34284 wxString const &arg4_defvalue = wxPyEmptyString ;
34285 wxString *arg4 = (wxString *) &arg4_defvalue ;
34286 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34287 wxMenuItem *result;
34288 bool temp3 = false ;
34289 bool temp4 = false ;
34290 PyObject * obj0 = 0 ;
34291 PyObject * obj1 = 0 ;
34292 PyObject * obj2 = 0 ;
34293 PyObject * obj3 = 0 ;
34294 PyObject * obj4 = 0 ;
34295 char *kwnames[] = {
34296 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34297 };
34298
34299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34301 if (SWIG_arg_fail(1)) SWIG_fail;
34302 {
34303 arg2 = static_cast<int >(SWIG_As_int(obj1));
34304 if (SWIG_arg_fail(2)) SWIG_fail;
34305 }
34306 {
34307 arg3 = wxString_in_helper(obj2);
34308 if (arg3 == NULL) SWIG_fail;
34309 temp3 = true;
34310 }
34311 if (obj3) {
34312 {
34313 arg4 = wxString_in_helper(obj3);
34314 if (arg4 == NULL) SWIG_fail;
34315 temp4 = true;
34316 }
34317 }
34318 if (obj4) {
34319 {
34320 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34321 if (SWIG_arg_fail(5)) SWIG_fail;
34322 }
34323 }
34324 {
34325 PyThreadState* __tstate = wxPyBeginAllowThreads();
34326 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34327
34328 wxPyEndAllowThreads(__tstate);
34329 if (PyErr_Occurred()) SWIG_fail;
34330 }
34331 {
34332 resultobj = wxPyMake_wxObject(result, (bool)0);
34333 }
34334 {
34335 if (temp3)
34336 delete arg3;
34337 }
34338 {
34339 if (temp4)
34340 delete arg4;
34341 }
34342 return resultobj;
34343 fail:
34344 {
34345 if (temp3)
34346 delete arg3;
34347 }
34348 {
34349 if (temp4)
34350 delete arg4;
34351 }
34352 return NULL;
34353 }
34354
34355
34356 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34357 PyObject *resultobj = NULL;
34358 wxMenu *arg1 = (wxMenu *) 0 ;
34359 wxMenuItem *result;
34360 PyObject * obj0 = 0 ;
34361 char *kwnames[] = {
34362 (char *) "self", NULL
34363 };
34364
34365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34367 if (SWIG_arg_fail(1)) SWIG_fail;
34368 {
34369 PyThreadState* __tstate = wxPyBeginAllowThreads();
34370 result = (wxMenuItem *)(arg1)->PrependSeparator();
34371
34372 wxPyEndAllowThreads(__tstate);
34373 if (PyErr_Occurred()) SWIG_fail;
34374 }
34375 {
34376 resultobj = wxPyMake_wxObject(result, (bool)0);
34377 }
34378 return resultobj;
34379 fail:
34380 return NULL;
34381 }
34382
34383
34384 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34385 PyObject *resultobj = NULL;
34386 wxMenu *arg1 = (wxMenu *) 0 ;
34387 int arg2 ;
34388 wxString *arg3 = 0 ;
34389 wxString const &arg4_defvalue = wxPyEmptyString ;
34390 wxString *arg4 = (wxString *) &arg4_defvalue ;
34391 wxMenuItem *result;
34392 bool temp3 = false ;
34393 bool temp4 = false ;
34394 PyObject * obj0 = 0 ;
34395 PyObject * obj1 = 0 ;
34396 PyObject * obj2 = 0 ;
34397 PyObject * obj3 = 0 ;
34398 char *kwnames[] = {
34399 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34400 };
34401
34402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34404 if (SWIG_arg_fail(1)) SWIG_fail;
34405 {
34406 arg2 = static_cast<int >(SWIG_As_int(obj1));
34407 if (SWIG_arg_fail(2)) SWIG_fail;
34408 }
34409 {
34410 arg3 = wxString_in_helper(obj2);
34411 if (arg3 == NULL) SWIG_fail;
34412 temp3 = true;
34413 }
34414 if (obj3) {
34415 {
34416 arg4 = wxString_in_helper(obj3);
34417 if (arg4 == NULL) SWIG_fail;
34418 temp4 = true;
34419 }
34420 }
34421 {
34422 PyThreadState* __tstate = wxPyBeginAllowThreads();
34423 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34424
34425 wxPyEndAllowThreads(__tstate);
34426 if (PyErr_Occurred()) SWIG_fail;
34427 }
34428 {
34429 resultobj = wxPyMake_wxObject(result, (bool)0);
34430 }
34431 {
34432 if (temp3)
34433 delete arg3;
34434 }
34435 {
34436 if (temp4)
34437 delete arg4;
34438 }
34439 return resultobj;
34440 fail:
34441 {
34442 if (temp3)
34443 delete arg3;
34444 }
34445 {
34446 if (temp4)
34447 delete arg4;
34448 }
34449 return NULL;
34450 }
34451
34452
34453 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34454 PyObject *resultobj = NULL;
34455 wxMenu *arg1 = (wxMenu *) 0 ;
34456 int arg2 ;
34457 wxString *arg3 = 0 ;
34458 wxString const &arg4_defvalue = wxPyEmptyString ;
34459 wxString *arg4 = (wxString *) &arg4_defvalue ;
34460 wxMenuItem *result;
34461 bool temp3 = false ;
34462 bool temp4 = false ;
34463 PyObject * obj0 = 0 ;
34464 PyObject * obj1 = 0 ;
34465 PyObject * obj2 = 0 ;
34466 PyObject * obj3 = 0 ;
34467 char *kwnames[] = {
34468 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34469 };
34470
34471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34473 if (SWIG_arg_fail(1)) SWIG_fail;
34474 {
34475 arg2 = static_cast<int >(SWIG_As_int(obj1));
34476 if (SWIG_arg_fail(2)) SWIG_fail;
34477 }
34478 {
34479 arg3 = wxString_in_helper(obj2);
34480 if (arg3 == NULL) SWIG_fail;
34481 temp3 = true;
34482 }
34483 if (obj3) {
34484 {
34485 arg4 = wxString_in_helper(obj3);
34486 if (arg4 == NULL) SWIG_fail;
34487 temp4 = true;
34488 }
34489 }
34490 {
34491 PyThreadState* __tstate = wxPyBeginAllowThreads();
34492 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34493
34494 wxPyEndAllowThreads(__tstate);
34495 if (PyErr_Occurred()) SWIG_fail;
34496 }
34497 {
34498 resultobj = wxPyMake_wxObject(result, (bool)0);
34499 }
34500 {
34501 if (temp3)
34502 delete arg3;
34503 }
34504 {
34505 if (temp4)
34506 delete arg4;
34507 }
34508 return resultobj;
34509 fail:
34510 {
34511 if (temp3)
34512 delete arg3;
34513 }
34514 {
34515 if (temp4)
34516 delete arg4;
34517 }
34518 return NULL;
34519 }
34520
34521
34522 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34523 PyObject *resultobj = NULL;
34524 wxMenu *arg1 = (wxMenu *) 0 ;
34525 int arg2 ;
34526 wxString *arg3 = 0 ;
34527 wxMenu *arg4 = (wxMenu *) 0 ;
34528 wxString const &arg5_defvalue = wxPyEmptyString ;
34529 wxString *arg5 = (wxString *) &arg5_defvalue ;
34530 wxMenuItem *result;
34531 bool temp3 = false ;
34532 bool temp5 = false ;
34533 PyObject * obj0 = 0 ;
34534 PyObject * obj1 = 0 ;
34535 PyObject * obj2 = 0 ;
34536 PyObject * obj3 = 0 ;
34537 PyObject * obj4 = 0 ;
34538 char *kwnames[] = {
34539 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34540 };
34541
34542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34544 if (SWIG_arg_fail(1)) SWIG_fail;
34545 {
34546 arg2 = static_cast<int >(SWIG_As_int(obj1));
34547 if (SWIG_arg_fail(2)) SWIG_fail;
34548 }
34549 {
34550 arg3 = wxString_in_helper(obj2);
34551 if (arg3 == NULL) SWIG_fail;
34552 temp3 = true;
34553 }
34554 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34555 if (SWIG_arg_fail(4)) SWIG_fail;
34556 if (obj4) {
34557 {
34558 arg5 = wxString_in_helper(obj4);
34559 if (arg5 == NULL) SWIG_fail;
34560 temp5 = true;
34561 }
34562 }
34563 {
34564 PyThreadState* __tstate = wxPyBeginAllowThreads();
34565 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34566
34567 wxPyEndAllowThreads(__tstate);
34568 if (PyErr_Occurred()) SWIG_fail;
34569 }
34570 {
34571 resultobj = wxPyMake_wxObject(result, (bool)0);
34572 }
34573 {
34574 if (temp3)
34575 delete arg3;
34576 }
34577 {
34578 if (temp5)
34579 delete arg5;
34580 }
34581 return resultobj;
34582 fail:
34583 {
34584 if (temp3)
34585 delete arg3;
34586 }
34587 {
34588 if (temp5)
34589 delete arg5;
34590 }
34591 return NULL;
34592 }
34593
34594
34595 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34596 PyObject *resultobj = NULL;
34597 wxMenu *arg1 = (wxMenu *) 0 ;
34598 int arg2 ;
34599 wxMenuItem *result;
34600 PyObject * obj0 = 0 ;
34601 PyObject * obj1 = 0 ;
34602 char *kwnames[] = {
34603 (char *) "self",(char *) "id", NULL
34604 };
34605
34606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34608 if (SWIG_arg_fail(1)) SWIG_fail;
34609 {
34610 arg2 = static_cast<int >(SWIG_As_int(obj1));
34611 if (SWIG_arg_fail(2)) SWIG_fail;
34612 }
34613 {
34614 PyThreadState* __tstate = wxPyBeginAllowThreads();
34615 result = (wxMenuItem *)(arg1)->Remove(arg2);
34616
34617 wxPyEndAllowThreads(__tstate);
34618 if (PyErr_Occurred()) SWIG_fail;
34619 }
34620 {
34621 resultobj = wxPyMake_wxObject(result, (bool)0);
34622 }
34623 return resultobj;
34624 fail:
34625 return NULL;
34626 }
34627
34628
34629 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34630 PyObject *resultobj = NULL;
34631 wxMenu *arg1 = (wxMenu *) 0 ;
34632 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34633 wxMenuItem *result;
34634 PyObject * obj0 = 0 ;
34635 PyObject * obj1 = 0 ;
34636 char *kwnames[] = {
34637 (char *) "self",(char *) "item", NULL
34638 };
34639
34640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34642 if (SWIG_arg_fail(1)) SWIG_fail;
34643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34644 if (SWIG_arg_fail(2)) SWIG_fail;
34645 {
34646 PyThreadState* __tstate = wxPyBeginAllowThreads();
34647 result = (wxMenuItem *)(arg1)->Remove(arg2);
34648
34649 wxPyEndAllowThreads(__tstate);
34650 if (PyErr_Occurred()) SWIG_fail;
34651 }
34652 {
34653 resultobj = wxPyMake_wxObject(result, (bool)0);
34654 }
34655 return resultobj;
34656 fail:
34657 return NULL;
34658 }
34659
34660
34661 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34662 PyObject *resultobj = NULL;
34663 wxMenu *arg1 = (wxMenu *) 0 ;
34664 int arg2 ;
34665 bool result;
34666 PyObject * obj0 = 0 ;
34667 PyObject * obj1 = 0 ;
34668 char *kwnames[] = {
34669 (char *) "self",(char *) "id", NULL
34670 };
34671
34672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34674 if (SWIG_arg_fail(1)) SWIG_fail;
34675 {
34676 arg2 = static_cast<int >(SWIG_As_int(obj1));
34677 if (SWIG_arg_fail(2)) SWIG_fail;
34678 }
34679 {
34680 PyThreadState* __tstate = wxPyBeginAllowThreads();
34681 result = (bool)(arg1)->Delete(arg2);
34682
34683 wxPyEndAllowThreads(__tstate);
34684 if (PyErr_Occurred()) SWIG_fail;
34685 }
34686 {
34687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34688 }
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj = NULL;
34697 wxMenu *arg1 = (wxMenu *) 0 ;
34698 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34699 bool result;
34700 PyObject * obj0 = 0 ;
34701 PyObject * obj1 = 0 ;
34702 char *kwnames[] = {
34703 (char *) "self",(char *) "item", NULL
34704 };
34705
34706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34708 if (SWIG_arg_fail(1)) SWIG_fail;
34709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34710 if (SWIG_arg_fail(2)) SWIG_fail;
34711 {
34712 PyThreadState* __tstate = wxPyBeginAllowThreads();
34713 result = (bool)(arg1)->Delete(arg2);
34714
34715 wxPyEndAllowThreads(__tstate);
34716 if (PyErr_Occurred()) SWIG_fail;
34717 }
34718 {
34719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34720 }
34721 return resultobj;
34722 fail:
34723 return NULL;
34724 }
34725
34726
34727 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34728 PyObject *resultobj = NULL;
34729 wxMenu *arg1 = (wxMenu *) 0 ;
34730 PyObject * obj0 = 0 ;
34731 char *kwnames[] = {
34732 (char *) "self", NULL
34733 };
34734
34735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34737 if (SWIG_arg_fail(1)) SWIG_fail;
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 wxMenu_Destroy(arg1);
34741
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 Py_INCREF(Py_None); resultobj = Py_None;
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34753 PyObject *resultobj = NULL;
34754 wxMenu *arg1 = (wxMenu *) 0 ;
34755 int arg2 ;
34756 bool result;
34757 PyObject * obj0 = 0 ;
34758 PyObject * obj1 = 0 ;
34759 char *kwnames[] = {
34760 (char *) "self",(char *) "id", NULL
34761 };
34762
34763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34765 if (SWIG_arg_fail(1)) SWIG_fail;
34766 {
34767 arg2 = static_cast<int >(SWIG_As_int(obj1));
34768 if (SWIG_arg_fail(2)) SWIG_fail;
34769 }
34770 {
34771 PyThreadState* __tstate = wxPyBeginAllowThreads();
34772 result = (bool)(arg1)->Destroy(arg2);
34773
34774 wxPyEndAllowThreads(__tstate);
34775 if (PyErr_Occurred()) SWIG_fail;
34776 }
34777 {
34778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34779 }
34780 return resultobj;
34781 fail:
34782 return NULL;
34783 }
34784
34785
34786 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34787 PyObject *resultobj = NULL;
34788 wxMenu *arg1 = (wxMenu *) 0 ;
34789 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34790 bool result;
34791 PyObject * obj0 = 0 ;
34792 PyObject * obj1 = 0 ;
34793 char *kwnames[] = {
34794 (char *) "self",(char *) "item", NULL
34795 };
34796
34797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34801 if (SWIG_arg_fail(2)) SWIG_fail;
34802 {
34803 PyThreadState* __tstate = wxPyBeginAllowThreads();
34804 result = (bool)(arg1)->Destroy(arg2);
34805
34806 wxPyEndAllowThreads(__tstate);
34807 if (PyErr_Occurred()) SWIG_fail;
34808 }
34809 {
34810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34811 }
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34819 PyObject *resultobj = NULL;
34820 wxMenu *arg1 = (wxMenu *) 0 ;
34821 size_t result;
34822 PyObject * obj0 = 0 ;
34823 char *kwnames[] = {
34824 (char *) "self", NULL
34825 };
34826
34827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34829 if (SWIG_arg_fail(1)) SWIG_fail;
34830 {
34831 PyThreadState* __tstate = wxPyBeginAllowThreads();
34832 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34833
34834 wxPyEndAllowThreads(__tstate);
34835 if (PyErr_Occurred()) SWIG_fail;
34836 }
34837 {
34838 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34839 }
34840 return resultobj;
34841 fail:
34842 return NULL;
34843 }
34844
34845
34846 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj = NULL;
34848 wxMenu *arg1 = (wxMenu *) 0 ;
34849 PyObject *result;
34850 PyObject * obj0 = 0 ;
34851 char *kwnames[] = {
34852 (char *) "self", NULL
34853 };
34854
34855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34857 if (SWIG_arg_fail(1)) SWIG_fail;
34858 {
34859 PyThreadState* __tstate = wxPyBeginAllowThreads();
34860 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34861
34862 wxPyEndAllowThreads(__tstate);
34863 if (PyErr_Occurred()) SWIG_fail;
34864 }
34865 resultobj = result;
34866 return resultobj;
34867 fail:
34868 return NULL;
34869 }
34870
34871
34872 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34873 PyObject *resultobj = NULL;
34874 wxMenu *arg1 = (wxMenu *) 0 ;
34875 wxString *arg2 = 0 ;
34876 int result;
34877 bool temp2 = false ;
34878 PyObject * obj0 = 0 ;
34879 PyObject * obj1 = 0 ;
34880 char *kwnames[] = {
34881 (char *) "self",(char *) "item", NULL
34882 };
34883
34884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34886 if (SWIG_arg_fail(1)) SWIG_fail;
34887 {
34888 arg2 = wxString_in_helper(obj1);
34889 if (arg2 == NULL) SWIG_fail;
34890 temp2 = true;
34891 }
34892 {
34893 PyThreadState* __tstate = wxPyBeginAllowThreads();
34894 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34895
34896 wxPyEndAllowThreads(__tstate);
34897 if (PyErr_Occurred()) SWIG_fail;
34898 }
34899 {
34900 resultobj = SWIG_From_int(static_cast<int >(result));
34901 }
34902 {
34903 if (temp2)
34904 delete arg2;
34905 }
34906 return resultobj;
34907 fail:
34908 {
34909 if (temp2)
34910 delete arg2;
34911 }
34912 return NULL;
34913 }
34914
34915
34916 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34917 PyObject *resultobj = NULL;
34918 wxMenu *arg1 = (wxMenu *) 0 ;
34919 int arg2 ;
34920 wxMenuItem *result;
34921 PyObject * obj0 = 0 ;
34922 PyObject * obj1 = 0 ;
34923 char *kwnames[] = {
34924 (char *) "self",(char *) "id", NULL
34925 };
34926
34927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34929 if (SWIG_arg_fail(1)) SWIG_fail;
34930 {
34931 arg2 = static_cast<int >(SWIG_As_int(obj1));
34932 if (SWIG_arg_fail(2)) SWIG_fail;
34933 }
34934 {
34935 PyThreadState* __tstate = wxPyBeginAllowThreads();
34936 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34937
34938 wxPyEndAllowThreads(__tstate);
34939 if (PyErr_Occurred()) SWIG_fail;
34940 }
34941 {
34942 resultobj = wxPyMake_wxObject(result, (bool)0);
34943 }
34944 return resultobj;
34945 fail:
34946 return NULL;
34947 }
34948
34949
34950 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34951 PyObject *resultobj = NULL;
34952 wxMenu *arg1 = (wxMenu *) 0 ;
34953 size_t arg2 ;
34954 wxMenuItem *result;
34955 PyObject * obj0 = 0 ;
34956 PyObject * obj1 = 0 ;
34957 char *kwnames[] = {
34958 (char *) "self",(char *) "position", NULL
34959 };
34960
34961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34963 if (SWIG_arg_fail(1)) SWIG_fail;
34964 {
34965 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34966 if (SWIG_arg_fail(2)) SWIG_fail;
34967 }
34968 {
34969 PyThreadState* __tstate = wxPyBeginAllowThreads();
34970 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34971
34972 wxPyEndAllowThreads(__tstate);
34973 if (PyErr_Occurred()) SWIG_fail;
34974 }
34975 {
34976 resultobj = wxPyMake_wxObject(result, (bool)0);
34977 }
34978 return resultobj;
34979 fail:
34980 return NULL;
34981 }
34982
34983
34984 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34985 PyObject *resultobj = NULL;
34986 wxMenu *arg1 = (wxMenu *) 0 ;
34987 int arg2 ;
34988 bool arg3 ;
34989 PyObject * obj0 = 0 ;
34990 PyObject * obj1 = 0 ;
34991 PyObject * obj2 = 0 ;
34992 char *kwnames[] = {
34993 (char *) "self",(char *) "id",(char *) "enable", NULL
34994 };
34995
34996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34998 if (SWIG_arg_fail(1)) SWIG_fail;
34999 {
35000 arg2 = static_cast<int >(SWIG_As_int(obj1));
35001 if (SWIG_arg_fail(2)) SWIG_fail;
35002 }
35003 {
35004 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35005 if (SWIG_arg_fail(3)) SWIG_fail;
35006 }
35007 {
35008 PyThreadState* __tstate = wxPyBeginAllowThreads();
35009 (arg1)->Enable(arg2,arg3);
35010
35011 wxPyEndAllowThreads(__tstate);
35012 if (PyErr_Occurred()) SWIG_fail;
35013 }
35014 Py_INCREF(Py_None); resultobj = Py_None;
35015 return resultobj;
35016 fail:
35017 return NULL;
35018 }
35019
35020
35021 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35022 PyObject *resultobj = NULL;
35023 wxMenu *arg1 = (wxMenu *) 0 ;
35024 int arg2 ;
35025 bool result;
35026 PyObject * obj0 = 0 ;
35027 PyObject * obj1 = 0 ;
35028 char *kwnames[] = {
35029 (char *) "self",(char *) "id", NULL
35030 };
35031
35032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35034 if (SWIG_arg_fail(1)) SWIG_fail;
35035 {
35036 arg2 = static_cast<int >(SWIG_As_int(obj1));
35037 if (SWIG_arg_fail(2)) SWIG_fail;
35038 }
35039 {
35040 PyThreadState* __tstate = wxPyBeginAllowThreads();
35041 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35042
35043 wxPyEndAllowThreads(__tstate);
35044 if (PyErr_Occurred()) SWIG_fail;
35045 }
35046 {
35047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35048 }
35049 return resultobj;
35050 fail:
35051 return NULL;
35052 }
35053
35054
35055 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35056 PyObject *resultobj = NULL;
35057 wxMenu *arg1 = (wxMenu *) 0 ;
35058 int arg2 ;
35059 bool arg3 ;
35060 PyObject * obj0 = 0 ;
35061 PyObject * obj1 = 0 ;
35062 PyObject * obj2 = 0 ;
35063 char *kwnames[] = {
35064 (char *) "self",(char *) "id",(char *) "check", NULL
35065 };
35066
35067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35069 if (SWIG_arg_fail(1)) SWIG_fail;
35070 {
35071 arg2 = static_cast<int >(SWIG_As_int(obj1));
35072 if (SWIG_arg_fail(2)) SWIG_fail;
35073 }
35074 {
35075 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35076 if (SWIG_arg_fail(3)) SWIG_fail;
35077 }
35078 {
35079 PyThreadState* __tstate = wxPyBeginAllowThreads();
35080 (arg1)->Check(arg2,arg3);
35081
35082 wxPyEndAllowThreads(__tstate);
35083 if (PyErr_Occurred()) SWIG_fail;
35084 }
35085 Py_INCREF(Py_None); resultobj = Py_None;
35086 return resultobj;
35087 fail:
35088 return NULL;
35089 }
35090
35091
35092 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35093 PyObject *resultobj = NULL;
35094 wxMenu *arg1 = (wxMenu *) 0 ;
35095 int arg2 ;
35096 bool result;
35097 PyObject * obj0 = 0 ;
35098 PyObject * obj1 = 0 ;
35099 char *kwnames[] = {
35100 (char *) "self",(char *) "id", NULL
35101 };
35102
35103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35105 if (SWIG_arg_fail(1)) SWIG_fail;
35106 {
35107 arg2 = static_cast<int >(SWIG_As_int(obj1));
35108 if (SWIG_arg_fail(2)) SWIG_fail;
35109 }
35110 {
35111 PyThreadState* __tstate = wxPyBeginAllowThreads();
35112 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35113
35114 wxPyEndAllowThreads(__tstate);
35115 if (PyErr_Occurred()) SWIG_fail;
35116 }
35117 {
35118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35119 }
35120 return resultobj;
35121 fail:
35122 return NULL;
35123 }
35124
35125
35126 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35127 PyObject *resultobj = NULL;
35128 wxMenu *arg1 = (wxMenu *) 0 ;
35129 int arg2 ;
35130 wxString *arg3 = 0 ;
35131 bool temp3 = false ;
35132 PyObject * obj0 = 0 ;
35133 PyObject * obj1 = 0 ;
35134 PyObject * obj2 = 0 ;
35135 char *kwnames[] = {
35136 (char *) "self",(char *) "id",(char *) "label", NULL
35137 };
35138
35139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35141 if (SWIG_arg_fail(1)) SWIG_fail;
35142 {
35143 arg2 = static_cast<int >(SWIG_As_int(obj1));
35144 if (SWIG_arg_fail(2)) SWIG_fail;
35145 }
35146 {
35147 arg3 = wxString_in_helper(obj2);
35148 if (arg3 == NULL) SWIG_fail;
35149 temp3 = true;
35150 }
35151 {
35152 PyThreadState* __tstate = wxPyBeginAllowThreads();
35153 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35154
35155 wxPyEndAllowThreads(__tstate);
35156 if (PyErr_Occurred()) SWIG_fail;
35157 }
35158 Py_INCREF(Py_None); resultobj = Py_None;
35159 {
35160 if (temp3)
35161 delete arg3;
35162 }
35163 return resultobj;
35164 fail:
35165 {
35166 if (temp3)
35167 delete arg3;
35168 }
35169 return NULL;
35170 }
35171
35172
35173 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35174 PyObject *resultobj = NULL;
35175 wxMenu *arg1 = (wxMenu *) 0 ;
35176 int arg2 ;
35177 wxString result;
35178 PyObject * obj0 = 0 ;
35179 PyObject * obj1 = 0 ;
35180 char *kwnames[] = {
35181 (char *) "self",(char *) "id", NULL
35182 };
35183
35184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35186 if (SWIG_arg_fail(1)) SWIG_fail;
35187 {
35188 arg2 = static_cast<int >(SWIG_As_int(obj1));
35189 if (SWIG_arg_fail(2)) SWIG_fail;
35190 }
35191 {
35192 PyThreadState* __tstate = wxPyBeginAllowThreads();
35193 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35194
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 {
35199 #if wxUSE_UNICODE
35200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35201 #else
35202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35203 #endif
35204 }
35205 return resultobj;
35206 fail:
35207 return NULL;
35208 }
35209
35210
35211 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35212 PyObject *resultobj = NULL;
35213 wxMenu *arg1 = (wxMenu *) 0 ;
35214 int arg2 ;
35215 wxString *arg3 = 0 ;
35216 bool temp3 = false ;
35217 PyObject * obj0 = 0 ;
35218 PyObject * obj1 = 0 ;
35219 PyObject * obj2 = 0 ;
35220 char *kwnames[] = {
35221 (char *) "self",(char *) "id",(char *) "helpString", NULL
35222 };
35223
35224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35226 if (SWIG_arg_fail(1)) SWIG_fail;
35227 {
35228 arg2 = static_cast<int >(SWIG_As_int(obj1));
35229 if (SWIG_arg_fail(2)) SWIG_fail;
35230 }
35231 {
35232 arg3 = wxString_in_helper(obj2);
35233 if (arg3 == NULL) SWIG_fail;
35234 temp3 = true;
35235 }
35236 {
35237 PyThreadState* __tstate = wxPyBeginAllowThreads();
35238 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35239
35240 wxPyEndAllowThreads(__tstate);
35241 if (PyErr_Occurred()) SWIG_fail;
35242 }
35243 Py_INCREF(Py_None); resultobj = Py_None;
35244 {
35245 if (temp3)
35246 delete arg3;
35247 }
35248 return resultobj;
35249 fail:
35250 {
35251 if (temp3)
35252 delete arg3;
35253 }
35254 return NULL;
35255 }
35256
35257
35258 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35259 PyObject *resultobj = NULL;
35260 wxMenu *arg1 = (wxMenu *) 0 ;
35261 int arg2 ;
35262 wxString result;
35263 PyObject * obj0 = 0 ;
35264 PyObject * obj1 = 0 ;
35265 char *kwnames[] = {
35266 (char *) "self",(char *) "id", NULL
35267 };
35268
35269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35271 if (SWIG_arg_fail(1)) SWIG_fail;
35272 {
35273 arg2 = static_cast<int >(SWIG_As_int(obj1));
35274 if (SWIG_arg_fail(2)) SWIG_fail;
35275 }
35276 {
35277 PyThreadState* __tstate = wxPyBeginAllowThreads();
35278 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35279
35280 wxPyEndAllowThreads(__tstate);
35281 if (PyErr_Occurred()) SWIG_fail;
35282 }
35283 {
35284 #if wxUSE_UNICODE
35285 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35286 #else
35287 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35288 #endif
35289 }
35290 return resultobj;
35291 fail:
35292 return NULL;
35293 }
35294
35295
35296 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35297 PyObject *resultobj = NULL;
35298 wxMenu *arg1 = (wxMenu *) 0 ;
35299 wxString *arg2 = 0 ;
35300 bool temp2 = false ;
35301 PyObject * obj0 = 0 ;
35302 PyObject * obj1 = 0 ;
35303 char *kwnames[] = {
35304 (char *) "self",(char *) "title", NULL
35305 };
35306
35307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35309 if (SWIG_arg_fail(1)) SWIG_fail;
35310 {
35311 arg2 = wxString_in_helper(obj1);
35312 if (arg2 == NULL) SWIG_fail;
35313 temp2 = true;
35314 }
35315 {
35316 PyThreadState* __tstate = wxPyBeginAllowThreads();
35317 (arg1)->SetTitle((wxString const &)*arg2);
35318
35319 wxPyEndAllowThreads(__tstate);
35320 if (PyErr_Occurred()) SWIG_fail;
35321 }
35322 Py_INCREF(Py_None); resultobj = Py_None;
35323 {
35324 if (temp2)
35325 delete arg2;
35326 }
35327 return resultobj;
35328 fail:
35329 {
35330 if (temp2)
35331 delete arg2;
35332 }
35333 return NULL;
35334 }
35335
35336
35337 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35338 PyObject *resultobj = NULL;
35339 wxMenu *arg1 = (wxMenu *) 0 ;
35340 wxString result;
35341 PyObject * obj0 = 0 ;
35342 char *kwnames[] = {
35343 (char *) "self", NULL
35344 };
35345
35346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35348 if (SWIG_arg_fail(1)) SWIG_fail;
35349 {
35350 PyThreadState* __tstate = wxPyBeginAllowThreads();
35351 result = ((wxMenu const *)arg1)->GetTitle();
35352
35353 wxPyEndAllowThreads(__tstate);
35354 if (PyErr_Occurred()) SWIG_fail;
35355 }
35356 {
35357 #if wxUSE_UNICODE
35358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35359 #else
35360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35361 #endif
35362 }
35363 return resultobj;
35364 fail:
35365 return NULL;
35366 }
35367
35368
35369 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35370 PyObject *resultobj = NULL;
35371 wxMenu *arg1 = (wxMenu *) 0 ;
35372 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35373 PyObject * obj0 = 0 ;
35374 PyObject * obj1 = 0 ;
35375 char *kwnames[] = {
35376 (char *) "self",(char *) "handler", NULL
35377 };
35378
35379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35381 if (SWIG_arg_fail(1)) SWIG_fail;
35382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35383 if (SWIG_arg_fail(2)) SWIG_fail;
35384 {
35385 PyThreadState* __tstate = wxPyBeginAllowThreads();
35386 (arg1)->SetEventHandler(arg2);
35387
35388 wxPyEndAllowThreads(__tstate);
35389 if (PyErr_Occurred()) SWIG_fail;
35390 }
35391 Py_INCREF(Py_None); resultobj = Py_None;
35392 return resultobj;
35393 fail:
35394 return NULL;
35395 }
35396
35397
35398 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35399 PyObject *resultobj = NULL;
35400 wxMenu *arg1 = (wxMenu *) 0 ;
35401 wxEvtHandler *result;
35402 PyObject * obj0 = 0 ;
35403 char *kwnames[] = {
35404 (char *) "self", NULL
35405 };
35406
35407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35409 if (SWIG_arg_fail(1)) SWIG_fail;
35410 {
35411 PyThreadState* __tstate = wxPyBeginAllowThreads();
35412 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35413
35414 wxPyEndAllowThreads(__tstate);
35415 if (PyErr_Occurred()) SWIG_fail;
35416 }
35417 {
35418 resultobj = wxPyMake_wxObject(result, 0);
35419 }
35420 return resultobj;
35421 fail:
35422 return NULL;
35423 }
35424
35425
35426 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35427 PyObject *resultobj = NULL;
35428 wxMenu *arg1 = (wxMenu *) 0 ;
35429 wxWindow *arg2 = (wxWindow *) 0 ;
35430 PyObject * obj0 = 0 ;
35431 PyObject * obj1 = 0 ;
35432 char *kwnames[] = {
35433 (char *) "self",(char *) "win", NULL
35434 };
35435
35436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35438 if (SWIG_arg_fail(1)) SWIG_fail;
35439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35440 if (SWIG_arg_fail(2)) SWIG_fail;
35441 {
35442 PyThreadState* __tstate = wxPyBeginAllowThreads();
35443 (arg1)->SetInvokingWindow(arg2);
35444
35445 wxPyEndAllowThreads(__tstate);
35446 if (PyErr_Occurred()) SWIG_fail;
35447 }
35448 Py_INCREF(Py_None); resultobj = Py_None;
35449 return resultobj;
35450 fail:
35451 return NULL;
35452 }
35453
35454
35455 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35456 PyObject *resultobj = NULL;
35457 wxMenu *arg1 = (wxMenu *) 0 ;
35458 wxWindow *result;
35459 PyObject * obj0 = 0 ;
35460 char *kwnames[] = {
35461 (char *) "self", NULL
35462 };
35463
35464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35466 if (SWIG_arg_fail(1)) SWIG_fail;
35467 {
35468 PyThreadState* __tstate = wxPyBeginAllowThreads();
35469 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35470
35471 wxPyEndAllowThreads(__tstate);
35472 if (PyErr_Occurred()) SWIG_fail;
35473 }
35474 {
35475 resultobj = wxPyMake_wxObject(result, 0);
35476 }
35477 return resultobj;
35478 fail:
35479 return NULL;
35480 }
35481
35482
35483 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35484 PyObject *resultobj = NULL;
35485 wxMenu *arg1 = (wxMenu *) 0 ;
35486 long result;
35487 PyObject * obj0 = 0 ;
35488 char *kwnames[] = {
35489 (char *) "self", NULL
35490 };
35491
35492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35494 if (SWIG_arg_fail(1)) SWIG_fail;
35495 {
35496 PyThreadState* __tstate = wxPyBeginAllowThreads();
35497 result = (long)((wxMenu const *)arg1)->GetStyle();
35498
35499 wxPyEndAllowThreads(__tstate);
35500 if (PyErr_Occurred()) SWIG_fail;
35501 }
35502 {
35503 resultobj = SWIG_From_long(static_cast<long >(result));
35504 }
35505 return resultobj;
35506 fail:
35507 return NULL;
35508 }
35509
35510
35511 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35512 PyObject *resultobj = NULL;
35513 wxMenu *arg1 = (wxMenu *) 0 ;
35514 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35515 PyObject * obj0 = 0 ;
35516 PyObject * obj1 = 0 ;
35517 char *kwnames[] = {
35518 (char *) "self",(char *) "source", NULL
35519 };
35520
35521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35523 if (SWIG_arg_fail(1)) SWIG_fail;
35524 if (obj1) {
35525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35526 if (SWIG_arg_fail(2)) SWIG_fail;
35527 }
35528 {
35529 PyThreadState* __tstate = wxPyBeginAllowThreads();
35530 (arg1)->UpdateUI(arg2);
35531
35532 wxPyEndAllowThreads(__tstate);
35533 if (PyErr_Occurred()) SWIG_fail;
35534 }
35535 Py_INCREF(Py_None); resultobj = Py_None;
35536 return resultobj;
35537 fail:
35538 return NULL;
35539 }
35540
35541
35542 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35543 PyObject *resultobj = NULL;
35544 wxMenu *arg1 = (wxMenu *) 0 ;
35545 wxMenuBar *result;
35546 PyObject * obj0 = 0 ;
35547 char *kwnames[] = {
35548 (char *) "self", NULL
35549 };
35550
35551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35553 if (SWIG_arg_fail(1)) SWIG_fail;
35554 {
35555 PyThreadState* __tstate = wxPyBeginAllowThreads();
35556 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35557
35558 wxPyEndAllowThreads(__tstate);
35559 if (PyErr_Occurred()) SWIG_fail;
35560 }
35561 {
35562 resultobj = wxPyMake_wxObject(result, (bool)0);
35563 }
35564 return resultobj;
35565 fail:
35566 return NULL;
35567 }
35568
35569
35570 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35571 PyObject *resultobj = NULL;
35572 wxMenu *arg1 = (wxMenu *) 0 ;
35573 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35574 PyObject * obj0 = 0 ;
35575 PyObject * obj1 = 0 ;
35576 char *kwnames[] = {
35577 (char *) "self",(char *) "menubar", NULL
35578 };
35579
35580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35582 if (SWIG_arg_fail(1)) SWIG_fail;
35583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35584 if (SWIG_arg_fail(2)) SWIG_fail;
35585 {
35586 PyThreadState* __tstate = wxPyBeginAllowThreads();
35587 (arg1)->Attach(arg2);
35588
35589 wxPyEndAllowThreads(__tstate);
35590 if (PyErr_Occurred()) SWIG_fail;
35591 }
35592 Py_INCREF(Py_None); resultobj = Py_None;
35593 return resultobj;
35594 fail:
35595 return NULL;
35596 }
35597
35598
35599 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35600 PyObject *resultobj = NULL;
35601 wxMenu *arg1 = (wxMenu *) 0 ;
35602 PyObject * obj0 = 0 ;
35603 char *kwnames[] = {
35604 (char *) "self", NULL
35605 };
35606
35607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35609 if (SWIG_arg_fail(1)) SWIG_fail;
35610 {
35611 PyThreadState* __tstate = wxPyBeginAllowThreads();
35612 (arg1)->Detach();
35613
35614 wxPyEndAllowThreads(__tstate);
35615 if (PyErr_Occurred()) SWIG_fail;
35616 }
35617 Py_INCREF(Py_None); resultobj = Py_None;
35618 return resultobj;
35619 fail:
35620 return NULL;
35621 }
35622
35623
35624 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35625 PyObject *resultobj = NULL;
35626 wxMenu *arg1 = (wxMenu *) 0 ;
35627 bool result;
35628 PyObject * obj0 = 0 ;
35629 char *kwnames[] = {
35630 (char *) "self", NULL
35631 };
35632
35633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35635 if (SWIG_arg_fail(1)) SWIG_fail;
35636 {
35637 PyThreadState* __tstate = wxPyBeginAllowThreads();
35638 result = (bool)((wxMenu const *)arg1)->IsAttached();
35639
35640 wxPyEndAllowThreads(__tstate);
35641 if (PyErr_Occurred()) SWIG_fail;
35642 }
35643 {
35644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35645 }
35646 return resultobj;
35647 fail:
35648 return NULL;
35649 }
35650
35651
35652 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35653 PyObject *resultobj = NULL;
35654 wxMenu *arg1 = (wxMenu *) 0 ;
35655 wxMenu *arg2 = (wxMenu *) 0 ;
35656 PyObject * obj0 = 0 ;
35657 PyObject * obj1 = 0 ;
35658 char *kwnames[] = {
35659 (char *) "self",(char *) "parent", NULL
35660 };
35661
35662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35664 if (SWIG_arg_fail(1)) SWIG_fail;
35665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35666 if (SWIG_arg_fail(2)) SWIG_fail;
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 (arg1)->SetParent(arg2);
35670
35671 wxPyEndAllowThreads(__tstate);
35672 if (PyErr_Occurred()) SWIG_fail;
35673 }
35674 Py_INCREF(Py_None); resultobj = Py_None;
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35682 PyObject *resultobj = NULL;
35683 wxMenu *arg1 = (wxMenu *) 0 ;
35684 wxMenu *result;
35685 PyObject * obj0 = 0 ;
35686 char *kwnames[] = {
35687 (char *) "self", NULL
35688 };
35689
35690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35692 if (SWIG_arg_fail(1)) SWIG_fail;
35693 {
35694 PyThreadState* __tstate = wxPyBeginAllowThreads();
35695 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35696
35697 wxPyEndAllowThreads(__tstate);
35698 if (PyErr_Occurred()) SWIG_fail;
35699 }
35700 {
35701 resultobj = wxPyMake_wxObject(result, 0);
35702 }
35703 return resultobj;
35704 fail:
35705 return NULL;
35706 }
35707
35708
35709 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35710 PyObject *obj;
35711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35712 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35713 Py_INCREF(obj);
35714 return Py_BuildValue((char *)"");
35715 }
35716 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35717 PyObject *resultobj = NULL;
35718 long arg1 = (long) 0 ;
35719 wxMenuBar *result;
35720 PyObject * obj0 = 0 ;
35721 char *kwnames[] = {
35722 (char *) "style", NULL
35723 };
35724
35725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35726 if (obj0) {
35727 {
35728 arg1 = static_cast<long >(SWIG_As_long(obj0));
35729 if (SWIG_arg_fail(1)) SWIG_fail;
35730 }
35731 }
35732 {
35733 if (!wxPyCheckForApp()) SWIG_fail;
35734 PyThreadState* __tstate = wxPyBeginAllowThreads();
35735 result = (wxMenuBar *)new wxMenuBar(arg1);
35736
35737 wxPyEndAllowThreads(__tstate);
35738 if (PyErr_Occurred()) SWIG_fail;
35739 }
35740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35741 return resultobj;
35742 fail:
35743 return NULL;
35744 }
35745
35746
35747 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35748 PyObject *resultobj = NULL;
35749 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35750 wxMenu *arg2 = (wxMenu *) 0 ;
35751 wxString *arg3 = 0 ;
35752 bool result;
35753 bool temp3 = false ;
35754 PyObject * obj0 = 0 ;
35755 PyObject * obj1 = 0 ;
35756 PyObject * obj2 = 0 ;
35757 char *kwnames[] = {
35758 (char *) "self",(char *) "menu",(char *) "title", NULL
35759 };
35760
35761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35763 if (SWIG_arg_fail(1)) SWIG_fail;
35764 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35765 if (SWIG_arg_fail(2)) SWIG_fail;
35766 {
35767 arg3 = wxString_in_helper(obj2);
35768 if (arg3 == NULL) SWIG_fail;
35769 temp3 = true;
35770 }
35771 {
35772 PyThreadState* __tstate = wxPyBeginAllowThreads();
35773 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35774
35775 wxPyEndAllowThreads(__tstate);
35776 if (PyErr_Occurred()) SWIG_fail;
35777 }
35778 {
35779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35780 }
35781 {
35782 if (temp3)
35783 delete arg3;
35784 }
35785 return resultobj;
35786 fail:
35787 {
35788 if (temp3)
35789 delete arg3;
35790 }
35791 return NULL;
35792 }
35793
35794
35795 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35796 PyObject *resultobj = NULL;
35797 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35798 size_t arg2 ;
35799 wxMenu *arg3 = (wxMenu *) 0 ;
35800 wxString *arg4 = 0 ;
35801 bool result;
35802 bool temp4 = false ;
35803 PyObject * obj0 = 0 ;
35804 PyObject * obj1 = 0 ;
35805 PyObject * obj2 = 0 ;
35806 PyObject * obj3 = 0 ;
35807 char *kwnames[] = {
35808 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35809 };
35810
35811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35813 if (SWIG_arg_fail(1)) SWIG_fail;
35814 {
35815 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35816 if (SWIG_arg_fail(2)) SWIG_fail;
35817 }
35818 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35819 if (SWIG_arg_fail(3)) SWIG_fail;
35820 {
35821 arg4 = wxString_in_helper(obj3);
35822 if (arg4 == NULL) SWIG_fail;
35823 temp4 = true;
35824 }
35825 {
35826 PyThreadState* __tstate = wxPyBeginAllowThreads();
35827 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35828
35829 wxPyEndAllowThreads(__tstate);
35830 if (PyErr_Occurred()) SWIG_fail;
35831 }
35832 {
35833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35834 }
35835 {
35836 if (temp4)
35837 delete arg4;
35838 }
35839 return resultobj;
35840 fail:
35841 {
35842 if (temp4)
35843 delete arg4;
35844 }
35845 return NULL;
35846 }
35847
35848
35849 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35850 PyObject *resultobj = NULL;
35851 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35852 size_t result;
35853 PyObject * obj0 = 0 ;
35854 char *kwnames[] = {
35855 (char *) "self", NULL
35856 };
35857
35858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35860 if (SWIG_arg_fail(1)) SWIG_fail;
35861 {
35862 PyThreadState* __tstate = wxPyBeginAllowThreads();
35863 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35864
35865 wxPyEndAllowThreads(__tstate);
35866 if (PyErr_Occurred()) SWIG_fail;
35867 }
35868 {
35869 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35870 }
35871 return resultobj;
35872 fail:
35873 return NULL;
35874 }
35875
35876
35877 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35878 PyObject *resultobj = NULL;
35879 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35880 size_t arg2 ;
35881 wxMenu *result;
35882 PyObject * obj0 = 0 ;
35883 PyObject * obj1 = 0 ;
35884 char *kwnames[] = {
35885 (char *) "self",(char *) "pos", NULL
35886 };
35887
35888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35890 if (SWIG_arg_fail(1)) SWIG_fail;
35891 {
35892 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35893 if (SWIG_arg_fail(2)) SWIG_fail;
35894 }
35895 {
35896 PyThreadState* __tstate = wxPyBeginAllowThreads();
35897 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35898
35899 wxPyEndAllowThreads(__tstate);
35900 if (PyErr_Occurred()) SWIG_fail;
35901 }
35902 {
35903 resultobj = wxPyMake_wxObject(result, 0);
35904 }
35905 return resultobj;
35906 fail:
35907 return NULL;
35908 }
35909
35910
35911 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35912 PyObject *resultobj = NULL;
35913 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35914 size_t arg2 ;
35915 wxMenu *arg3 = (wxMenu *) 0 ;
35916 wxString *arg4 = 0 ;
35917 wxMenu *result;
35918 bool temp4 = false ;
35919 PyObject * obj0 = 0 ;
35920 PyObject * obj1 = 0 ;
35921 PyObject * obj2 = 0 ;
35922 PyObject * obj3 = 0 ;
35923 char *kwnames[] = {
35924 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35925 };
35926
35927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35929 if (SWIG_arg_fail(1)) SWIG_fail;
35930 {
35931 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35932 if (SWIG_arg_fail(2)) SWIG_fail;
35933 }
35934 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35935 if (SWIG_arg_fail(3)) SWIG_fail;
35936 {
35937 arg4 = wxString_in_helper(obj3);
35938 if (arg4 == NULL) SWIG_fail;
35939 temp4 = true;
35940 }
35941 {
35942 PyThreadState* __tstate = wxPyBeginAllowThreads();
35943 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35944
35945 wxPyEndAllowThreads(__tstate);
35946 if (PyErr_Occurred()) SWIG_fail;
35947 }
35948 {
35949 resultobj = wxPyMake_wxObject(result, 0);
35950 }
35951 {
35952 if (temp4)
35953 delete arg4;
35954 }
35955 return resultobj;
35956 fail:
35957 {
35958 if (temp4)
35959 delete arg4;
35960 }
35961 return NULL;
35962 }
35963
35964
35965 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35966 PyObject *resultobj = NULL;
35967 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35968 size_t arg2 ;
35969 wxMenu *result;
35970 PyObject * obj0 = 0 ;
35971 PyObject * obj1 = 0 ;
35972 char *kwnames[] = {
35973 (char *) "self",(char *) "pos", NULL
35974 };
35975
35976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35978 if (SWIG_arg_fail(1)) SWIG_fail;
35979 {
35980 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35981 if (SWIG_arg_fail(2)) SWIG_fail;
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = (wxMenu *)(arg1)->Remove(arg2);
35986
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 {
35991 resultobj = wxPyMake_wxObject(result, 0);
35992 }
35993 return resultobj;
35994 fail:
35995 return NULL;
35996 }
35997
35998
35999 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
36000 PyObject *resultobj = NULL;
36001 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36002 size_t arg2 ;
36003 bool arg3 ;
36004 PyObject * obj0 = 0 ;
36005 PyObject * obj1 = 0 ;
36006 PyObject * obj2 = 0 ;
36007 char *kwnames[] = {
36008 (char *) "self",(char *) "pos",(char *) "enable", NULL
36009 };
36010
36011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36013 if (SWIG_arg_fail(1)) SWIG_fail;
36014 {
36015 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36016 if (SWIG_arg_fail(2)) SWIG_fail;
36017 }
36018 {
36019 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36020 if (SWIG_arg_fail(3)) SWIG_fail;
36021 }
36022 {
36023 PyThreadState* __tstate = wxPyBeginAllowThreads();
36024 (arg1)->EnableTop(arg2,arg3);
36025
36026 wxPyEndAllowThreads(__tstate);
36027 if (PyErr_Occurred()) SWIG_fail;
36028 }
36029 Py_INCREF(Py_None); resultobj = Py_None;
36030 return resultobj;
36031 fail:
36032 return NULL;
36033 }
36034
36035
36036 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36037 PyObject *resultobj = NULL;
36038 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36039 size_t arg2 ;
36040 bool result;
36041 PyObject * obj0 = 0 ;
36042 PyObject * obj1 = 0 ;
36043 char *kwnames[] = {
36044 (char *) "self",(char *) "pos", NULL
36045 };
36046
36047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36049 if (SWIG_arg_fail(1)) SWIG_fail;
36050 {
36051 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36052 if (SWIG_arg_fail(2)) SWIG_fail;
36053 }
36054 {
36055 PyThreadState* __tstate = wxPyBeginAllowThreads();
36056 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36057
36058 wxPyEndAllowThreads(__tstate);
36059 if (PyErr_Occurred()) SWIG_fail;
36060 }
36061 {
36062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36063 }
36064 return resultobj;
36065 fail:
36066 return NULL;
36067 }
36068
36069
36070 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36071 PyObject *resultobj = NULL;
36072 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36073 size_t arg2 ;
36074 wxString *arg3 = 0 ;
36075 bool temp3 = false ;
36076 PyObject * obj0 = 0 ;
36077 PyObject * obj1 = 0 ;
36078 PyObject * obj2 = 0 ;
36079 char *kwnames[] = {
36080 (char *) "self",(char *) "pos",(char *) "label", NULL
36081 };
36082
36083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36085 if (SWIG_arg_fail(1)) SWIG_fail;
36086 {
36087 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36088 if (SWIG_arg_fail(2)) SWIG_fail;
36089 }
36090 {
36091 arg3 = wxString_in_helper(obj2);
36092 if (arg3 == NULL) SWIG_fail;
36093 temp3 = true;
36094 }
36095 {
36096 PyThreadState* __tstate = wxPyBeginAllowThreads();
36097 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36098
36099 wxPyEndAllowThreads(__tstate);
36100 if (PyErr_Occurred()) SWIG_fail;
36101 }
36102 Py_INCREF(Py_None); resultobj = Py_None;
36103 {
36104 if (temp3)
36105 delete arg3;
36106 }
36107 return resultobj;
36108 fail:
36109 {
36110 if (temp3)
36111 delete arg3;
36112 }
36113 return NULL;
36114 }
36115
36116
36117 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36118 PyObject *resultobj = NULL;
36119 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36120 size_t arg2 ;
36121 wxString result;
36122 PyObject * obj0 = 0 ;
36123 PyObject * obj1 = 0 ;
36124 char *kwnames[] = {
36125 (char *) "self",(char *) "pos", NULL
36126 };
36127
36128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36130 if (SWIG_arg_fail(1)) SWIG_fail;
36131 {
36132 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36133 if (SWIG_arg_fail(2)) SWIG_fail;
36134 }
36135 {
36136 PyThreadState* __tstate = wxPyBeginAllowThreads();
36137 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36138
36139 wxPyEndAllowThreads(__tstate);
36140 if (PyErr_Occurred()) SWIG_fail;
36141 }
36142 {
36143 #if wxUSE_UNICODE
36144 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36145 #else
36146 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36147 #endif
36148 }
36149 return resultobj;
36150 fail:
36151 return NULL;
36152 }
36153
36154
36155 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36156 PyObject *resultobj = NULL;
36157 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36158 wxString *arg2 = 0 ;
36159 wxString *arg3 = 0 ;
36160 int result;
36161 bool temp2 = false ;
36162 bool temp3 = false ;
36163 PyObject * obj0 = 0 ;
36164 PyObject * obj1 = 0 ;
36165 PyObject * obj2 = 0 ;
36166 char *kwnames[] = {
36167 (char *) "self",(char *) "menu",(char *) "item", NULL
36168 };
36169
36170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36172 if (SWIG_arg_fail(1)) SWIG_fail;
36173 {
36174 arg2 = wxString_in_helper(obj1);
36175 if (arg2 == NULL) SWIG_fail;
36176 temp2 = true;
36177 }
36178 {
36179 arg3 = wxString_in_helper(obj2);
36180 if (arg3 == NULL) SWIG_fail;
36181 temp3 = true;
36182 }
36183 {
36184 PyThreadState* __tstate = wxPyBeginAllowThreads();
36185 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36186
36187 wxPyEndAllowThreads(__tstate);
36188 if (PyErr_Occurred()) SWIG_fail;
36189 }
36190 {
36191 resultobj = SWIG_From_int(static_cast<int >(result));
36192 }
36193 {
36194 if (temp2)
36195 delete arg2;
36196 }
36197 {
36198 if (temp3)
36199 delete arg3;
36200 }
36201 return resultobj;
36202 fail:
36203 {
36204 if (temp2)
36205 delete arg2;
36206 }
36207 {
36208 if (temp3)
36209 delete arg3;
36210 }
36211 return NULL;
36212 }
36213
36214
36215 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36216 PyObject *resultobj = NULL;
36217 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36218 int arg2 ;
36219 wxMenuItem *result;
36220 PyObject * obj0 = 0 ;
36221 PyObject * obj1 = 0 ;
36222 char *kwnames[] = {
36223 (char *) "self",(char *) "id", NULL
36224 };
36225
36226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36228 if (SWIG_arg_fail(1)) SWIG_fail;
36229 {
36230 arg2 = static_cast<int >(SWIG_As_int(obj1));
36231 if (SWIG_arg_fail(2)) SWIG_fail;
36232 }
36233 {
36234 PyThreadState* __tstate = wxPyBeginAllowThreads();
36235 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36236
36237 wxPyEndAllowThreads(__tstate);
36238 if (PyErr_Occurred()) SWIG_fail;
36239 }
36240 {
36241 resultobj = wxPyMake_wxObject(result, (bool)0);
36242 }
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36250 PyObject *resultobj = NULL;
36251 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36252 wxString *arg2 = 0 ;
36253 int result;
36254 bool temp2 = false ;
36255 PyObject * obj0 = 0 ;
36256 PyObject * obj1 = 0 ;
36257 char *kwnames[] = {
36258 (char *) "self",(char *) "title", NULL
36259 };
36260
36261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36263 if (SWIG_arg_fail(1)) SWIG_fail;
36264 {
36265 arg2 = wxString_in_helper(obj1);
36266 if (arg2 == NULL) SWIG_fail;
36267 temp2 = true;
36268 }
36269 {
36270 PyThreadState* __tstate = wxPyBeginAllowThreads();
36271 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36272
36273 wxPyEndAllowThreads(__tstate);
36274 if (PyErr_Occurred()) SWIG_fail;
36275 }
36276 {
36277 resultobj = SWIG_From_int(static_cast<int >(result));
36278 }
36279 {
36280 if (temp2)
36281 delete arg2;
36282 }
36283 return resultobj;
36284 fail:
36285 {
36286 if (temp2)
36287 delete arg2;
36288 }
36289 return NULL;
36290 }
36291
36292
36293 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36294 PyObject *resultobj = NULL;
36295 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36296 int arg2 ;
36297 bool arg3 ;
36298 PyObject * obj0 = 0 ;
36299 PyObject * obj1 = 0 ;
36300 PyObject * obj2 = 0 ;
36301 char *kwnames[] = {
36302 (char *) "self",(char *) "id",(char *) "enable", NULL
36303 };
36304
36305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36307 if (SWIG_arg_fail(1)) SWIG_fail;
36308 {
36309 arg2 = static_cast<int >(SWIG_As_int(obj1));
36310 if (SWIG_arg_fail(2)) SWIG_fail;
36311 }
36312 {
36313 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36314 if (SWIG_arg_fail(3)) SWIG_fail;
36315 }
36316 {
36317 PyThreadState* __tstate = wxPyBeginAllowThreads();
36318 (arg1)->Enable(arg2,arg3);
36319
36320 wxPyEndAllowThreads(__tstate);
36321 if (PyErr_Occurred()) SWIG_fail;
36322 }
36323 Py_INCREF(Py_None); resultobj = Py_None;
36324 return resultobj;
36325 fail:
36326 return NULL;
36327 }
36328
36329
36330 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36331 PyObject *resultobj = NULL;
36332 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36333 int arg2 ;
36334 bool arg3 ;
36335 PyObject * obj0 = 0 ;
36336 PyObject * obj1 = 0 ;
36337 PyObject * obj2 = 0 ;
36338 char *kwnames[] = {
36339 (char *) "self",(char *) "id",(char *) "check", NULL
36340 };
36341
36342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36344 if (SWIG_arg_fail(1)) SWIG_fail;
36345 {
36346 arg2 = static_cast<int >(SWIG_As_int(obj1));
36347 if (SWIG_arg_fail(2)) SWIG_fail;
36348 }
36349 {
36350 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36351 if (SWIG_arg_fail(3)) SWIG_fail;
36352 }
36353 {
36354 PyThreadState* __tstate = wxPyBeginAllowThreads();
36355 (arg1)->Check(arg2,arg3);
36356
36357 wxPyEndAllowThreads(__tstate);
36358 if (PyErr_Occurred()) SWIG_fail;
36359 }
36360 Py_INCREF(Py_None); resultobj = Py_None;
36361 return resultobj;
36362 fail:
36363 return NULL;
36364 }
36365
36366
36367 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36368 PyObject *resultobj = NULL;
36369 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36370 int arg2 ;
36371 bool result;
36372 PyObject * obj0 = 0 ;
36373 PyObject * obj1 = 0 ;
36374 char *kwnames[] = {
36375 (char *) "self",(char *) "id", NULL
36376 };
36377
36378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36380 if (SWIG_arg_fail(1)) SWIG_fail;
36381 {
36382 arg2 = static_cast<int >(SWIG_As_int(obj1));
36383 if (SWIG_arg_fail(2)) SWIG_fail;
36384 }
36385 {
36386 PyThreadState* __tstate = wxPyBeginAllowThreads();
36387 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36388
36389 wxPyEndAllowThreads(__tstate);
36390 if (PyErr_Occurred()) SWIG_fail;
36391 }
36392 {
36393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36394 }
36395 return resultobj;
36396 fail:
36397 return NULL;
36398 }
36399
36400
36401 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36402 PyObject *resultobj = NULL;
36403 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36404 int arg2 ;
36405 bool result;
36406 PyObject * obj0 = 0 ;
36407 PyObject * obj1 = 0 ;
36408 char *kwnames[] = {
36409 (char *) "self",(char *) "id", NULL
36410 };
36411
36412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36414 if (SWIG_arg_fail(1)) SWIG_fail;
36415 {
36416 arg2 = static_cast<int >(SWIG_As_int(obj1));
36417 if (SWIG_arg_fail(2)) SWIG_fail;
36418 }
36419 {
36420 PyThreadState* __tstate = wxPyBeginAllowThreads();
36421 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36422
36423 wxPyEndAllowThreads(__tstate);
36424 if (PyErr_Occurred()) SWIG_fail;
36425 }
36426 {
36427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36428 }
36429 return resultobj;
36430 fail:
36431 return NULL;
36432 }
36433
36434
36435 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36436 PyObject *resultobj = NULL;
36437 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36438 int arg2 ;
36439 wxString *arg3 = 0 ;
36440 bool temp3 = false ;
36441 PyObject * obj0 = 0 ;
36442 PyObject * obj1 = 0 ;
36443 PyObject * obj2 = 0 ;
36444 char *kwnames[] = {
36445 (char *) "self",(char *) "id",(char *) "label", NULL
36446 };
36447
36448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36450 if (SWIG_arg_fail(1)) SWIG_fail;
36451 {
36452 arg2 = static_cast<int >(SWIG_As_int(obj1));
36453 if (SWIG_arg_fail(2)) SWIG_fail;
36454 }
36455 {
36456 arg3 = wxString_in_helper(obj2);
36457 if (arg3 == NULL) SWIG_fail;
36458 temp3 = true;
36459 }
36460 {
36461 PyThreadState* __tstate = wxPyBeginAllowThreads();
36462 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36463
36464 wxPyEndAllowThreads(__tstate);
36465 if (PyErr_Occurred()) SWIG_fail;
36466 }
36467 Py_INCREF(Py_None); resultobj = Py_None;
36468 {
36469 if (temp3)
36470 delete arg3;
36471 }
36472 return resultobj;
36473 fail:
36474 {
36475 if (temp3)
36476 delete arg3;
36477 }
36478 return NULL;
36479 }
36480
36481
36482 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36483 PyObject *resultobj = NULL;
36484 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36485 int arg2 ;
36486 wxString result;
36487 PyObject * obj0 = 0 ;
36488 PyObject * obj1 = 0 ;
36489 char *kwnames[] = {
36490 (char *) "self",(char *) "id", NULL
36491 };
36492
36493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36495 if (SWIG_arg_fail(1)) SWIG_fail;
36496 {
36497 arg2 = static_cast<int >(SWIG_As_int(obj1));
36498 if (SWIG_arg_fail(2)) SWIG_fail;
36499 }
36500 {
36501 PyThreadState* __tstate = wxPyBeginAllowThreads();
36502 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36503
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 {
36508 #if wxUSE_UNICODE
36509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36510 #else
36511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36512 #endif
36513 }
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36521 PyObject *resultobj = NULL;
36522 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36523 int arg2 ;
36524 wxString *arg3 = 0 ;
36525 bool temp3 = false ;
36526 PyObject * obj0 = 0 ;
36527 PyObject * obj1 = 0 ;
36528 PyObject * obj2 = 0 ;
36529 char *kwnames[] = {
36530 (char *) "self",(char *) "id",(char *) "helpString", NULL
36531 };
36532
36533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36535 if (SWIG_arg_fail(1)) SWIG_fail;
36536 {
36537 arg2 = static_cast<int >(SWIG_As_int(obj1));
36538 if (SWIG_arg_fail(2)) SWIG_fail;
36539 }
36540 {
36541 arg3 = wxString_in_helper(obj2);
36542 if (arg3 == NULL) SWIG_fail;
36543 temp3 = true;
36544 }
36545 {
36546 PyThreadState* __tstate = wxPyBeginAllowThreads();
36547 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36548
36549 wxPyEndAllowThreads(__tstate);
36550 if (PyErr_Occurred()) SWIG_fail;
36551 }
36552 Py_INCREF(Py_None); resultobj = Py_None;
36553 {
36554 if (temp3)
36555 delete arg3;
36556 }
36557 return resultobj;
36558 fail:
36559 {
36560 if (temp3)
36561 delete arg3;
36562 }
36563 return NULL;
36564 }
36565
36566
36567 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36568 PyObject *resultobj = NULL;
36569 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36570 int arg2 ;
36571 wxString result;
36572 PyObject * obj0 = 0 ;
36573 PyObject * obj1 = 0 ;
36574 char *kwnames[] = {
36575 (char *) "self",(char *) "id", NULL
36576 };
36577
36578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36580 if (SWIG_arg_fail(1)) SWIG_fail;
36581 {
36582 arg2 = static_cast<int >(SWIG_As_int(obj1));
36583 if (SWIG_arg_fail(2)) SWIG_fail;
36584 }
36585 {
36586 PyThreadState* __tstate = wxPyBeginAllowThreads();
36587 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36588
36589 wxPyEndAllowThreads(__tstate);
36590 if (PyErr_Occurred()) SWIG_fail;
36591 }
36592 {
36593 #if wxUSE_UNICODE
36594 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36595 #else
36596 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36597 #endif
36598 }
36599 return resultobj;
36600 fail:
36601 return NULL;
36602 }
36603
36604
36605 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36606 PyObject *resultobj = NULL;
36607 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36608 wxFrame *result;
36609 PyObject * obj0 = 0 ;
36610 char *kwnames[] = {
36611 (char *) "self", NULL
36612 };
36613
36614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36616 if (SWIG_arg_fail(1)) SWIG_fail;
36617 {
36618 PyThreadState* __tstate = wxPyBeginAllowThreads();
36619 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36620
36621 wxPyEndAllowThreads(__tstate);
36622 if (PyErr_Occurred()) SWIG_fail;
36623 }
36624 {
36625 resultobj = wxPyMake_wxObject(result, (bool)0);
36626 }
36627 return resultobj;
36628 fail:
36629 return NULL;
36630 }
36631
36632
36633 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36634 PyObject *resultobj = NULL;
36635 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36636 bool result;
36637 PyObject * obj0 = 0 ;
36638 char *kwnames[] = {
36639 (char *) "self", NULL
36640 };
36641
36642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36644 if (SWIG_arg_fail(1)) SWIG_fail;
36645 {
36646 PyThreadState* __tstate = wxPyBeginAllowThreads();
36647 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36648
36649 wxPyEndAllowThreads(__tstate);
36650 if (PyErr_Occurred()) SWIG_fail;
36651 }
36652 {
36653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36654 }
36655 return resultobj;
36656 fail:
36657 return NULL;
36658 }
36659
36660
36661 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36662 PyObject *resultobj = NULL;
36663 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36664 wxFrame *arg2 = (wxFrame *) 0 ;
36665 PyObject * obj0 = 0 ;
36666 PyObject * obj1 = 0 ;
36667 char *kwnames[] = {
36668 (char *) "self",(char *) "frame", NULL
36669 };
36670
36671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36673 if (SWIG_arg_fail(1)) SWIG_fail;
36674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36675 if (SWIG_arg_fail(2)) SWIG_fail;
36676 {
36677 PyThreadState* __tstate = wxPyBeginAllowThreads();
36678 (arg1)->Attach(arg2);
36679
36680 wxPyEndAllowThreads(__tstate);
36681 if (PyErr_Occurred()) SWIG_fail;
36682 }
36683 Py_INCREF(Py_None); resultobj = Py_None;
36684 return resultobj;
36685 fail:
36686 return NULL;
36687 }
36688
36689
36690 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36691 PyObject *resultobj = NULL;
36692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36693 PyObject * obj0 = 0 ;
36694 char *kwnames[] = {
36695 (char *) "self", NULL
36696 };
36697
36698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36700 if (SWIG_arg_fail(1)) SWIG_fail;
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 (arg1)->Detach();
36704
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 Py_INCREF(Py_None); resultobj = Py_None;
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36716 PyObject *resultobj = NULL;
36717 bool arg1 ;
36718 PyObject * obj0 = 0 ;
36719 char *kwnames[] = {
36720 (char *) "enable", NULL
36721 };
36722
36723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36724 {
36725 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36726 if (SWIG_arg_fail(1)) SWIG_fail;
36727 }
36728 {
36729 PyThreadState* __tstate = wxPyBeginAllowThreads();
36730 wxMenuBar::SetAutoWindowMenu(arg1);
36731
36732 wxPyEndAllowThreads(__tstate);
36733 if (PyErr_Occurred()) SWIG_fail;
36734 }
36735 Py_INCREF(Py_None); resultobj = Py_None;
36736 return resultobj;
36737 fail:
36738 return NULL;
36739 }
36740
36741
36742 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36743 PyObject *resultobj = NULL;
36744 bool result;
36745 char *kwnames[] = {
36746 NULL
36747 };
36748
36749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 result = (bool)wxMenuBar::GetAutoWindowMenu();
36753
36754 wxPyEndAllowThreads(__tstate);
36755 if (PyErr_Occurred()) SWIG_fail;
36756 }
36757 {
36758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36759 }
36760 return resultobj;
36761 fail:
36762 return NULL;
36763 }
36764
36765
36766 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36767 PyObject *obj;
36768 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36769 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36770 Py_INCREF(obj);
36771 return Py_BuildValue((char *)"");
36772 }
36773 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36774 PyObject *resultobj = NULL;
36775 wxMenu *arg1 = (wxMenu *) NULL ;
36776 int arg2 = (int) wxID_ANY ;
36777 wxString const &arg3_defvalue = wxPyEmptyString ;
36778 wxString *arg3 = (wxString *) &arg3_defvalue ;
36779 wxString const &arg4_defvalue = wxPyEmptyString ;
36780 wxString *arg4 = (wxString *) &arg4_defvalue ;
36781 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36782 wxMenu *arg6 = (wxMenu *) NULL ;
36783 wxMenuItem *result;
36784 bool temp3 = false ;
36785 bool temp4 = false ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 PyObject * obj2 = 0 ;
36789 PyObject * obj3 = 0 ;
36790 PyObject * obj4 = 0 ;
36791 PyObject * obj5 = 0 ;
36792 char *kwnames[] = {
36793 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36794 };
36795
36796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36797 if (obj0) {
36798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36799 if (SWIG_arg_fail(1)) SWIG_fail;
36800 }
36801 if (obj1) {
36802 {
36803 arg2 = static_cast<int >(SWIG_As_int(obj1));
36804 if (SWIG_arg_fail(2)) SWIG_fail;
36805 }
36806 }
36807 if (obj2) {
36808 {
36809 arg3 = wxString_in_helper(obj2);
36810 if (arg3 == NULL) SWIG_fail;
36811 temp3 = true;
36812 }
36813 }
36814 if (obj3) {
36815 {
36816 arg4 = wxString_in_helper(obj3);
36817 if (arg4 == NULL) SWIG_fail;
36818 temp4 = true;
36819 }
36820 }
36821 if (obj4) {
36822 {
36823 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36824 if (SWIG_arg_fail(5)) SWIG_fail;
36825 }
36826 }
36827 if (obj5) {
36828 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36829 if (SWIG_arg_fail(6)) SWIG_fail;
36830 }
36831 {
36832 PyThreadState* __tstate = wxPyBeginAllowThreads();
36833 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36834
36835 wxPyEndAllowThreads(__tstate);
36836 if (PyErr_Occurred()) SWIG_fail;
36837 }
36838 {
36839 resultobj = wxPyMake_wxObject(result, (bool)1);
36840 }
36841 {
36842 if (temp3)
36843 delete arg3;
36844 }
36845 {
36846 if (temp4)
36847 delete arg4;
36848 }
36849 return resultobj;
36850 fail:
36851 {
36852 if (temp3)
36853 delete arg3;
36854 }
36855 {
36856 if (temp4)
36857 delete arg4;
36858 }
36859 return NULL;
36860 }
36861
36862
36863 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36864 PyObject *resultobj = NULL;
36865 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36866 wxMenu *result;
36867 PyObject * obj0 = 0 ;
36868 char *kwnames[] = {
36869 (char *) "self", NULL
36870 };
36871
36872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36874 if (SWIG_arg_fail(1)) SWIG_fail;
36875 {
36876 PyThreadState* __tstate = wxPyBeginAllowThreads();
36877 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36878
36879 wxPyEndAllowThreads(__tstate);
36880 if (PyErr_Occurred()) SWIG_fail;
36881 }
36882 {
36883 resultobj = wxPyMake_wxObject(result, 0);
36884 }
36885 return resultobj;
36886 fail:
36887 return NULL;
36888 }
36889
36890
36891 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36892 PyObject *resultobj = NULL;
36893 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36894 wxMenu *arg2 = (wxMenu *) 0 ;
36895 PyObject * obj0 = 0 ;
36896 PyObject * obj1 = 0 ;
36897 char *kwnames[] = {
36898 (char *) "self",(char *) "menu", NULL
36899 };
36900
36901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36903 if (SWIG_arg_fail(1)) SWIG_fail;
36904 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36905 if (SWIG_arg_fail(2)) SWIG_fail;
36906 {
36907 PyThreadState* __tstate = wxPyBeginAllowThreads();
36908 (arg1)->SetMenu(arg2);
36909
36910 wxPyEndAllowThreads(__tstate);
36911 if (PyErr_Occurred()) SWIG_fail;
36912 }
36913 Py_INCREF(Py_None); resultobj = Py_None;
36914 return resultobj;
36915 fail:
36916 return NULL;
36917 }
36918
36919
36920 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36921 PyObject *resultobj = NULL;
36922 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36923 int arg2 ;
36924 PyObject * obj0 = 0 ;
36925 PyObject * obj1 = 0 ;
36926 char *kwnames[] = {
36927 (char *) "self",(char *) "id", NULL
36928 };
36929
36930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36932 if (SWIG_arg_fail(1)) SWIG_fail;
36933 {
36934 arg2 = static_cast<int >(SWIG_As_int(obj1));
36935 if (SWIG_arg_fail(2)) SWIG_fail;
36936 }
36937 {
36938 PyThreadState* __tstate = wxPyBeginAllowThreads();
36939 (arg1)->SetId(arg2);
36940
36941 wxPyEndAllowThreads(__tstate);
36942 if (PyErr_Occurred()) SWIG_fail;
36943 }
36944 Py_INCREF(Py_None); resultobj = Py_None;
36945 return resultobj;
36946 fail:
36947 return NULL;
36948 }
36949
36950
36951 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36952 PyObject *resultobj = NULL;
36953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36954 int result;
36955 PyObject * obj0 = 0 ;
36956 char *kwnames[] = {
36957 (char *) "self", NULL
36958 };
36959
36960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36962 if (SWIG_arg_fail(1)) SWIG_fail;
36963 {
36964 PyThreadState* __tstate = wxPyBeginAllowThreads();
36965 result = (int)((wxMenuItem const *)arg1)->GetId();
36966
36967 wxPyEndAllowThreads(__tstate);
36968 if (PyErr_Occurred()) SWIG_fail;
36969 }
36970 {
36971 resultobj = SWIG_From_int(static_cast<int >(result));
36972 }
36973 return resultobj;
36974 fail:
36975 return NULL;
36976 }
36977
36978
36979 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36980 PyObject *resultobj = NULL;
36981 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36982 bool result;
36983 PyObject * obj0 = 0 ;
36984 char *kwnames[] = {
36985 (char *) "self", NULL
36986 };
36987
36988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36990 if (SWIG_arg_fail(1)) SWIG_fail;
36991 {
36992 PyThreadState* __tstate = wxPyBeginAllowThreads();
36993 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36994
36995 wxPyEndAllowThreads(__tstate);
36996 if (PyErr_Occurred()) SWIG_fail;
36997 }
36998 {
36999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37000 }
37001 return resultobj;
37002 fail:
37003 return NULL;
37004 }
37005
37006
37007 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
37008 PyObject *resultobj = NULL;
37009 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37010 wxString *arg2 = 0 ;
37011 bool temp2 = false ;
37012 PyObject * obj0 = 0 ;
37013 PyObject * obj1 = 0 ;
37014 char *kwnames[] = {
37015 (char *) "self",(char *) "str", NULL
37016 };
37017
37018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37020 if (SWIG_arg_fail(1)) SWIG_fail;
37021 {
37022 arg2 = wxString_in_helper(obj1);
37023 if (arg2 == NULL) SWIG_fail;
37024 temp2 = true;
37025 }
37026 {
37027 PyThreadState* __tstate = wxPyBeginAllowThreads();
37028 (arg1)->SetText((wxString const &)*arg2);
37029
37030 wxPyEndAllowThreads(__tstate);
37031 if (PyErr_Occurred()) SWIG_fail;
37032 }
37033 Py_INCREF(Py_None); resultobj = Py_None;
37034 {
37035 if (temp2)
37036 delete arg2;
37037 }
37038 return resultobj;
37039 fail:
37040 {
37041 if (temp2)
37042 delete arg2;
37043 }
37044 return NULL;
37045 }
37046
37047
37048 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37049 PyObject *resultobj = NULL;
37050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37051 wxString result;
37052 PyObject * obj0 = 0 ;
37053 char *kwnames[] = {
37054 (char *) "self", NULL
37055 };
37056
37057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37059 if (SWIG_arg_fail(1)) SWIG_fail;
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 result = ((wxMenuItem const *)arg1)->GetLabel();
37063
37064 wxPyEndAllowThreads(__tstate);
37065 if (PyErr_Occurred()) SWIG_fail;
37066 }
37067 {
37068 #if wxUSE_UNICODE
37069 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37070 #else
37071 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37072 #endif
37073 }
37074 return resultobj;
37075 fail:
37076 return NULL;
37077 }
37078
37079
37080 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37081 PyObject *resultobj = NULL;
37082 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37083 wxString *result;
37084 PyObject * obj0 = 0 ;
37085 char *kwnames[] = {
37086 (char *) "self", NULL
37087 };
37088
37089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37091 if (SWIG_arg_fail(1)) SWIG_fail;
37092 {
37093 PyThreadState* __tstate = wxPyBeginAllowThreads();
37094 {
37095 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37096 result = (wxString *) &_result_ref;
37097 }
37098
37099 wxPyEndAllowThreads(__tstate);
37100 if (PyErr_Occurred()) SWIG_fail;
37101 }
37102 {
37103 #if wxUSE_UNICODE
37104 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37105 #else
37106 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37107 #endif
37108 }
37109 return resultobj;
37110 fail:
37111 return NULL;
37112 }
37113
37114
37115 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37116 PyObject *resultobj = NULL;
37117 wxString *arg1 = 0 ;
37118 wxString result;
37119 bool temp1 = false ;
37120 PyObject * obj0 = 0 ;
37121 char *kwnames[] = {
37122 (char *) "text", NULL
37123 };
37124
37125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37126 {
37127 arg1 = wxString_in_helper(obj0);
37128 if (arg1 == NULL) SWIG_fail;
37129 temp1 = true;
37130 }
37131 {
37132 PyThreadState* __tstate = wxPyBeginAllowThreads();
37133 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37134
37135 wxPyEndAllowThreads(__tstate);
37136 if (PyErr_Occurred()) SWIG_fail;
37137 }
37138 {
37139 #if wxUSE_UNICODE
37140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37141 #else
37142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37143 #endif
37144 }
37145 {
37146 if (temp1)
37147 delete arg1;
37148 }
37149 return resultobj;
37150 fail:
37151 {
37152 if (temp1)
37153 delete arg1;
37154 }
37155 return NULL;
37156 }
37157
37158
37159 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37160 PyObject *resultobj = NULL;
37161 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37162 wxItemKind result;
37163 PyObject * obj0 = 0 ;
37164 char *kwnames[] = {
37165 (char *) "self", NULL
37166 };
37167
37168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37170 if (SWIG_arg_fail(1)) SWIG_fail;
37171 {
37172 PyThreadState* __tstate = wxPyBeginAllowThreads();
37173 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37174
37175 wxPyEndAllowThreads(__tstate);
37176 if (PyErr_Occurred()) SWIG_fail;
37177 }
37178 resultobj = SWIG_From_int((result));
37179 return resultobj;
37180 fail:
37181 return NULL;
37182 }
37183
37184
37185 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37186 PyObject *resultobj = NULL;
37187 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37188 wxItemKind arg2 ;
37189 PyObject * obj0 = 0 ;
37190 PyObject * obj1 = 0 ;
37191 char *kwnames[] = {
37192 (char *) "self",(char *) "kind", NULL
37193 };
37194
37195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37197 if (SWIG_arg_fail(1)) SWIG_fail;
37198 {
37199 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37200 if (SWIG_arg_fail(2)) SWIG_fail;
37201 }
37202 {
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 (arg1)->SetKind(arg2);
37205
37206 wxPyEndAllowThreads(__tstate);
37207 if (PyErr_Occurred()) SWIG_fail;
37208 }
37209 Py_INCREF(Py_None); resultobj = Py_None;
37210 return resultobj;
37211 fail:
37212 return NULL;
37213 }
37214
37215
37216 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37217 PyObject *resultobj = NULL;
37218 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37219 bool arg2 ;
37220 PyObject * obj0 = 0 ;
37221 PyObject * obj1 = 0 ;
37222 char *kwnames[] = {
37223 (char *) "self",(char *) "checkable", NULL
37224 };
37225
37226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37228 if (SWIG_arg_fail(1)) SWIG_fail;
37229 {
37230 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37231 if (SWIG_arg_fail(2)) SWIG_fail;
37232 }
37233 {
37234 PyThreadState* __tstate = wxPyBeginAllowThreads();
37235 (arg1)->SetCheckable(arg2);
37236
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 Py_INCREF(Py_None); resultobj = Py_None;
37241 return resultobj;
37242 fail:
37243 return NULL;
37244 }
37245
37246
37247 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37248 PyObject *resultobj = NULL;
37249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37250 bool result;
37251 PyObject * obj0 = 0 ;
37252 char *kwnames[] = {
37253 (char *) "self", NULL
37254 };
37255
37256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37258 if (SWIG_arg_fail(1)) SWIG_fail;
37259 {
37260 PyThreadState* __tstate = wxPyBeginAllowThreads();
37261 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37262
37263 wxPyEndAllowThreads(__tstate);
37264 if (PyErr_Occurred()) SWIG_fail;
37265 }
37266 {
37267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37268 }
37269 return resultobj;
37270 fail:
37271 return NULL;
37272 }
37273
37274
37275 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37276 PyObject *resultobj = NULL;
37277 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37278 bool result;
37279 PyObject * obj0 = 0 ;
37280 char *kwnames[] = {
37281 (char *) "self", NULL
37282 };
37283
37284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37286 if (SWIG_arg_fail(1)) SWIG_fail;
37287 {
37288 PyThreadState* __tstate = wxPyBeginAllowThreads();
37289 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37290
37291 wxPyEndAllowThreads(__tstate);
37292 if (PyErr_Occurred()) SWIG_fail;
37293 }
37294 {
37295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37296 }
37297 return resultobj;
37298 fail:
37299 return NULL;
37300 }
37301
37302
37303 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37304 PyObject *resultobj = NULL;
37305 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37306 wxMenu *arg2 = (wxMenu *) 0 ;
37307 PyObject * obj0 = 0 ;
37308 PyObject * obj1 = 0 ;
37309 char *kwnames[] = {
37310 (char *) "self",(char *) "menu", NULL
37311 };
37312
37313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37315 if (SWIG_arg_fail(1)) SWIG_fail;
37316 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37317 if (SWIG_arg_fail(2)) SWIG_fail;
37318 {
37319 PyThreadState* __tstate = wxPyBeginAllowThreads();
37320 (arg1)->SetSubMenu(arg2);
37321
37322 wxPyEndAllowThreads(__tstate);
37323 if (PyErr_Occurred()) SWIG_fail;
37324 }
37325 Py_INCREF(Py_None); resultobj = Py_None;
37326 return resultobj;
37327 fail:
37328 return NULL;
37329 }
37330
37331
37332 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37333 PyObject *resultobj = NULL;
37334 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37335 wxMenu *result;
37336 PyObject * obj0 = 0 ;
37337 char *kwnames[] = {
37338 (char *) "self", NULL
37339 };
37340
37341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37343 if (SWIG_arg_fail(1)) SWIG_fail;
37344 {
37345 PyThreadState* __tstate = wxPyBeginAllowThreads();
37346 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37347
37348 wxPyEndAllowThreads(__tstate);
37349 if (PyErr_Occurred()) SWIG_fail;
37350 }
37351 {
37352 resultobj = wxPyMake_wxObject(result, 0);
37353 }
37354 return resultobj;
37355 fail:
37356 return NULL;
37357 }
37358
37359
37360 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37361 PyObject *resultobj = NULL;
37362 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37363 bool arg2 = (bool) true ;
37364 PyObject * obj0 = 0 ;
37365 PyObject * obj1 = 0 ;
37366 char *kwnames[] = {
37367 (char *) "self",(char *) "enable", NULL
37368 };
37369
37370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37372 if (SWIG_arg_fail(1)) SWIG_fail;
37373 if (obj1) {
37374 {
37375 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37376 if (SWIG_arg_fail(2)) SWIG_fail;
37377 }
37378 }
37379 {
37380 PyThreadState* __tstate = wxPyBeginAllowThreads();
37381 (arg1)->Enable(arg2);
37382
37383 wxPyEndAllowThreads(__tstate);
37384 if (PyErr_Occurred()) SWIG_fail;
37385 }
37386 Py_INCREF(Py_None); resultobj = Py_None;
37387 return resultobj;
37388 fail:
37389 return NULL;
37390 }
37391
37392
37393 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37394 PyObject *resultobj = NULL;
37395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37396 bool result;
37397 PyObject * obj0 = 0 ;
37398 char *kwnames[] = {
37399 (char *) "self", NULL
37400 };
37401
37402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37404 if (SWIG_arg_fail(1)) SWIG_fail;
37405 {
37406 PyThreadState* __tstate = wxPyBeginAllowThreads();
37407 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37408
37409 wxPyEndAllowThreads(__tstate);
37410 if (PyErr_Occurred()) SWIG_fail;
37411 }
37412 {
37413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37414 }
37415 return resultobj;
37416 fail:
37417 return NULL;
37418 }
37419
37420
37421 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37422 PyObject *resultobj = NULL;
37423 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37424 bool arg2 = (bool) true ;
37425 PyObject * obj0 = 0 ;
37426 PyObject * obj1 = 0 ;
37427 char *kwnames[] = {
37428 (char *) "self",(char *) "check", NULL
37429 };
37430
37431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37433 if (SWIG_arg_fail(1)) SWIG_fail;
37434 if (obj1) {
37435 {
37436 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37437 if (SWIG_arg_fail(2)) SWIG_fail;
37438 }
37439 }
37440 {
37441 PyThreadState* __tstate = wxPyBeginAllowThreads();
37442 (arg1)->Check(arg2);
37443
37444 wxPyEndAllowThreads(__tstate);
37445 if (PyErr_Occurred()) SWIG_fail;
37446 }
37447 Py_INCREF(Py_None); resultobj = Py_None;
37448 return resultobj;
37449 fail:
37450 return NULL;
37451 }
37452
37453
37454 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37455 PyObject *resultobj = NULL;
37456 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37457 bool result;
37458 PyObject * obj0 = 0 ;
37459 char *kwnames[] = {
37460 (char *) "self", NULL
37461 };
37462
37463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37465 if (SWIG_arg_fail(1)) SWIG_fail;
37466 {
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37469
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 {
37474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37475 }
37476 return resultobj;
37477 fail:
37478 return NULL;
37479 }
37480
37481
37482 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37483 PyObject *resultobj = NULL;
37484 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37485 PyObject * obj0 = 0 ;
37486 char *kwnames[] = {
37487 (char *) "self", NULL
37488 };
37489
37490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37492 if (SWIG_arg_fail(1)) SWIG_fail;
37493 {
37494 PyThreadState* __tstate = wxPyBeginAllowThreads();
37495 (arg1)->Toggle();
37496
37497 wxPyEndAllowThreads(__tstate);
37498 if (PyErr_Occurred()) SWIG_fail;
37499 }
37500 Py_INCREF(Py_None); resultobj = Py_None;
37501 return resultobj;
37502 fail:
37503 return NULL;
37504 }
37505
37506
37507 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37508 PyObject *resultobj = NULL;
37509 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37510 wxString *arg2 = 0 ;
37511 bool temp2 = false ;
37512 PyObject * obj0 = 0 ;
37513 PyObject * obj1 = 0 ;
37514 char *kwnames[] = {
37515 (char *) "self",(char *) "str", NULL
37516 };
37517
37518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37520 if (SWIG_arg_fail(1)) SWIG_fail;
37521 {
37522 arg2 = wxString_in_helper(obj1);
37523 if (arg2 == NULL) SWIG_fail;
37524 temp2 = true;
37525 }
37526 {
37527 PyThreadState* __tstate = wxPyBeginAllowThreads();
37528 (arg1)->SetHelp((wxString const &)*arg2);
37529
37530 wxPyEndAllowThreads(__tstate);
37531 if (PyErr_Occurred()) SWIG_fail;
37532 }
37533 Py_INCREF(Py_None); resultobj = Py_None;
37534 {
37535 if (temp2)
37536 delete arg2;
37537 }
37538 return resultobj;
37539 fail:
37540 {
37541 if (temp2)
37542 delete arg2;
37543 }
37544 return NULL;
37545 }
37546
37547
37548 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37549 PyObject *resultobj = NULL;
37550 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37551 wxString *result;
37552 PyObject * obj0 = 0 ;
37553 char *kwnames[] = {
37554 (char *) "self", NULL
37555 };
37556
37557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37559 if (SWIG_arg_fail(1)) SWIG_fail;
37560 {
37561 PyThreadState* __tstate = wxPyBeginAllowThreads();
37562 {
37563 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37564 result = (wxString *) &_result_ref;
37565 }
37566
37567 wxPyEndAllowThreads(__tstate);
37568 if (PyErr_Occurred()) SWIG_fail;
37569 }
37570 {
37571 #if wxUSE_UNICODE
37572 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37573 #else
37574 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37575 #endif
37576 }
37577 return resultobj;
37578 fail:
37579 return NULL;
37580 }
37581
37582
37583 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37584 PyObject *resultobj = NULL;
37585 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37586 wxAcceleratorEntry *result;
37587 PyObject * obj0 = 0 ;
37588 char *kwnames[] = {
37589 (char *) "self", NULL
37590 };
37591
37592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37594 if (SWIG_arg_fail(1)) SWIG_fail;
37595 {
37596 PyThreadState* __tstate = wxPyBeginAllowThreads();
37597 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37598
37599 wxPyEndAllowThreads(__tstate);
37600 if (PyErr_Occurred()) SWIG_fail;
37601 }
37602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37603 return resultobj;
37604 fail:
37605 return NULL;
37606 }
37607
37608
37609 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37610 PyObject *resultobj = NULL;
37611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37612 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37613 PyObject * obj0 = 0 ;
37614 PyObject * obj1 = 0 ;
37615 char *kwnames[] = {
37616 (char *) "self",(char *) "accel", NULL
37617 };
37618
37619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37623 if (SWIG_arg_fail(2)) SWIG_fail;
37624 {
37625 PyThreadState* __tstate = wxPyBeginAllowThreads();
37626 (arg1)->SetAccel(arg2);
37627
37628 wxPyEndAllowThreads(__tstate);
37629 if (PyErr_Occurred()) SWIG_fail;
37630 }
37631 Py_INCREF(Py_None); resultobj = Py_None;
37632 return resultobj;
37633 fail:
37634 return NULL;
37635 }
37636
37637
37638 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37639 PyObject *resultobj = NULL;
37640 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37641 wxBitmap *arg2 = 0 ;
37642 PyObject * obj0 = 0 ;
37643 PyObject * obj1 = 0 ;
37644 char *kwnames[] = {
37645 (char *) "self",(char *) "bitmap", NULL
37646 };
37647
37648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37650 if (SWIG_arg_fail(1)) SWIG_fail;
37651 {
37652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37653 if (SWIG_arg_fail(2)) SWIG_fail;
37654 if (arg2 == NULL) {
37655 SWIG_null_ref("wxBitmap");
37656 }
37657 if (SWIG_arg_fail(2)) SWIG_fail;
37658 }
37659 {
37660 PyThreadState* __tstate = wxPyBeginAllowThreads();
37661 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37662
37663 wxPyEndAllowThreads(__tstate);
37664 if (PyErr_Occurred()) SWIG_fail;
37665 }
37666 Py_INCREF(Py_None); resultobj = Py_None;
37667 return resultobj;
37668 fail:
37669 return NULL;
37670 }
37671
37672
37673 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37674 PyObject *resultobj = NULL;
37675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37676 wxBitmap *result;
37677 PyObject * obj0 = 0 ;
37678 char *kwnames[] = {
37679 (char *) "self", NULL
37680 };
37681
37682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37684 if (SWIG_arg_fail(1)) SWIG_fail;
37685 {
37686 PyThreadState* __tstate = wxPyBeginAllowThreads();
37687 {
37688 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37689 result = (wxBitmap *) &_result_ref;
37690 }
37691
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 {
37696 wxBitmap* resultptr = new wxBitmap(*result);
37697 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37698 }
37699 return resultobj;
37700 fail:
37701 return NULL;
37702 }
37703
37704
37705 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37706 PyObject *resultobj = NULL;
37707 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37708 wxFont *arg2 = 0 ;
37709 PyObject * obj0 = 0 ;
37710 PyObject * obj1 = 0 ;
37711 char *kwnames[] = {
37712 (char *) "self",(char *) "font", NULL
37713 };
37714
37715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37717 if (SWIG_arg_fail(1)) SWIG_fail;
37718 {
37719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37720 if (SWIG_arg_fail(2)) SWIG_fail;
37721 if (arg2 == NULL) {
37722 SWIG_null_ref("wxFont");
37723 }
37724 if (SWIG_arg_fail(2)) SWIG_fail;
37725 }
37726 {
37727 PyThreadState* __tstate = wxPyBeginAllowThreads();
37728 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37729
37730 wxPyEndAllowThreads(__tstate);
37731 if (PyErr_Occurred()) SWIG_fail;
37732 }
37733 Py_INCREF(Py_None); resultobj = Py_None;
37734 return resultobj;
37735 fail:
37736 return NULL;
37737 }
37738
37739
37740 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37741 PyObject *resultobj = NULL;
37742 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37743 wxFont result;
37744 PyObject * obj0 = 0 ;
37745 char *kwnames[] = {
37746 (char *) "self", NULL
37747 };
37748
37749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37751 if (SWIG_arg_fail(1)) SWIG_fail;
37752 {
37753 PyThreadState* __tstate = wxPyBeginAllowThreads();
37754 result = wxMenuItem_GetFont(arg1);
37755
37756 wxPyEndAllowThreads(__tstate);
37757 if (PyErr_Occurred()) SWIG_fail;
37758 }
37759 {
37760 wxFont * resultptr;
37761 resultptr = new wxFont(static_cast<wxFont & >(result));
37762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37763 }
37764 return resultobj;
37765 fail:
37766 return NULL;
37767 }
37768
37769
37770 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37771 PyObject *resultobj = NULL;
37772 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37773 wxColour *arg2 = 0 ;
37774 wxColour temp2 ;
37775 PyObject * obj0 = 0 ;
37776 PyObject * obj1 = 0 ;
37777 char *kwnames[] = {
37778 (char *) "self",(char *) "colText", NULL
37779 };
37780
37781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37783 if (SWIG_arg_fail(1)) SWIG_fail;
37784 {
37785 arg2 = &temp2;
37786 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37787 }
37788 {
37789 PyThreadState* __tstate = wxPyBeginAllowThreads();
37790 wxMenuItem_SetTextColour(arg1,(wxColour 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_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37803 PyObject *resultobj = NULL;
37804 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37805 wxColour result;
37806 PyObject * obj0 = 0 ;
37807 char *kwnames[] = {
37808 (char *) "self", NULL
37809 };
37810
37811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",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 = wxMenuItem_GetTextColour(arg1);
37817
37818 wxPyEndAllowThreads(__tstate);
37819 if (PyErr_Occurred()) SWIG_fail;
37820 }
37821 {
37822 wxColour * resultptr;
37823 resultptr = new wxColour(static_cast<wxColour & >(result));
37824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37825 }
37826 return resultobj;
37827 fail:
37828 return NULL;
37829 }
37830
37831
37832 static PyObject *_wrap_MenuItem_SetBackgroundColour(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 *) "colBack", NULL
37841 };
37842
37843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",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 wxMenuItem_SetBackgroundColour(arg1,(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_GetBackgroundColour(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_GetBackgroundColour",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 = wxMenuItem_GetBackgroundColour(arg1);
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_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37895 PyObject *resultobj = NULL;
37896 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37897 wxBitmap *arg2 = 0 ;
37898 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37899 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37900 PyObject * obj0 = 0 ;
37901 PyObject * obj1 = 0 ;
37902 PyObject * obj2 = 0 ;
37903 char *kwnames[] = {
37904 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37905 };
37906
37907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37909 if (SWIG_arg_fail(1)) SWIG_fail;
37910 {
37911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37912 if (SWIG_arg_fail(2)) SWIG_fail;
37913 if (arg2 == NULL) {
37914 SWIG_null_ref("wxBitmap");
37915 }
37916 if (SWIG_arg_fail(2)) SWIG_fail;
37917 }
37918 if (obj2) {
37919 {
37920 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37921 if (SWIG_arg_fail(3)) SWIG_fail;
37922 if (arg3 == NULL) {
37923 SWIG_null_ref("wxBitmap");
37924 }
37925 if (SWIG_arg_fail(3)) SWIG_fail;
37926 }
37927 }
37928 {
37929 PyThreadState* __tstate = wxPyBeginAllowThreads();
37930 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37931
37932 wxPyEndAllowThreads(__tstate);
37933 if (PyErr_Occurred()) SWIG_fail;
37934 }
37935 Py_INCREF(Py_None); resultobj = Py_None;
37936 return resultobj;
37937 fail:
37938 return NULL;
37939 }
37940
37941
37942 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37943 PyObject *resultobj = NULL;
37944 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37945 wxBitmap *arg2 = 0 ;
37946 PyObject * obj0 = 0 ;
37947 PyObject * obj1 = 0 ;
37948 char *kwnames[] = {
37949 (char *) "self",(char *) "bmpDisabled", NULL
37950 };
37951
37952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37954 if (SWIG_arg_fail(1)) SWIG_fail;
37955 {
37956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37957 if (SWIG_arg_fail(2)) SWIG_fail;
37958 if (arg2 == NULL) {
37959 SWIG_null_ref("wxBitmap");
37960 }
37961 if (SWIG_arg_fail(2)) SWIG_fail;
37962 }
37963 {
37964 PyThreadState* __tstate = wxPyBeginAllowThreads();
37965 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37966
37967 wxPyEndAllowThreads(__tstate);
37968 if (PyErr_Occurred()) SWIG_fail;
37969 }
37970 Py_INCREF(Py_None); resultobj = Py_None;
37971 return resultobj;
37972 fail:
37973 return NULL;
37974 }
37975
37976
37977 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37978 PyObject *resultobj = NULL;
37979 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37980 wxBitmap *result;
37981 PyObject * obj0 = 0 ;
37982 char *kwnames[] = {
37983 (char *) "self", NULL
37984 };
37985
37986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37988 if (SWIG_arg_fail(1)) SWIG_fail;
37989 {
37990 PyThreadState* __tstate = wxPyBeginAllowThreads();
37991 {
37992 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37993 result = (wxBitmap *) &_result_ref;
37994 }
37995
37996 wxPyEndAllowThreads(__tstate);
37997 if (PyErr_Occurred()) SWIG_fail;
37998 }
37999 {
38000 wxBitmap* resultptr = new wxBitmap(*result);
38001 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
38002 }
38003 return resultobj;
38004 fail:
38005 return NULL;
38006 }
38007
38008
38009 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38010 PyObject *resultobj = NULL;
38011 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38012 int arg2 ;
38013 PyObject * obj0 = 0 ;
38014 PyObject * obj1 = 0 ;
38015 char *kwnames[] = {
38016 (char *) "self",(char *) "nWidth", NULL
38017 };
38018
38019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38021 if (SWIG_arg_fail(1)) SWIG_fail;
38022 {
38023 arg2 = static_cast<int >(SWIG_As_int(obj1));
38024 if (SWIG_arg_fail(2)) SWIG_fail;
38025 }
38026 {
38027 PyThreadState* __tstate = wxPyBeginAllowThreads();
38028 wxMenuItem_SetMarginWidth(arg1,arg2);
38029
38030 wxPyEndAllowThreads(__tstate);
38031 if (PyErr_Occurred()) SWIG_fail;
38032 }
38033 Py_INCREF(Py_None); resultobj = Py_None;
38034 return resultobj;
38035 fail:
38036 return NULL;
38037 }
38038
38039
38040 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38041 PyObject *resultobj = NULL;
38042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38043 int result;
38044 PyObject * obj0 = 0 ;
38045 char *kwnames[] = {
38046 (char *) "self", NULL
38047 };
38048
38049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38051 if (SWIG_arg_fail(1)) SWIG_fail;
38052 {
38053 PyThreadState* __tstate = wxPyBeginAllowThreads();
38054 result = (int)wxMenuItem_GetMarginWidth(arg1);
38055
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 {
38060 resultobj = SWIG_From_int(static_cast<int >(result));
38061 }
38062 return resultobj;
38063 fail:
38064 return NULL;
38065 }
38066
38067
38068 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38069 PyObject *resultobj = NULL;
38070 int result;
38071 char *kwnames[] = {
38072 NULL
38073 };
38074
38075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38076 {
38077 PyThreadState* __tstate = wxPyBeginAllowThreads();
38078 result = (int)wxMenuItem_GetDefaultMarginWidth();
38079
38080 wxPyEndAllowThreads(__tstate);
38081 if (PyErr_Occurred()) SWIG_fail;
38082 }
38083 {
38084 resultobj = SWIG_From_int(static_cast<int >(result));
38085 }
38086 return resultobj;
38087 fail:
38088 return NULL;
38089 }
38090
38091
38092 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38093 PyObject *resultobj = NULL;
38094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38095 bool result;
38096 PyObject * obj0 = 0 ;
38097 char *kwnames[] = {
38098 (char *) "self", NULL
38099 };
38100
38101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38103 if (SWIG_arg_fail(1)) SWIG_fail;
38104 {
38105 PyThreadState* __tstate = wxPyBeginAllowThreads();
38106 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
38107
38108 wxPyEndAllowThreads(__tstate);
38109 if (PyErr_Occurred()) SWIG_fail;
38110 }
38111 {
38112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38113 }
38114 return resultobj;
38115 fail:
38116 return NULL;
38117 }
38118
38119
38120 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38121 PyObject *resultobj = NULL;
38122 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38123 bool arg2 = (bool) true ;
38124 PyObject * obj0 = 0 ;
38125 PyObject * obj1 = 0 ;
38126 char *kwnames[] = {
38127 (char *) "self",(char *) "ownerDrawn", NULL
38128 };
38129
38130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38132 if (SWIG_arg_fail(1)) SWIG_fail;
38133 if (obj1) {
38134 {
38135 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38136 if (SWIG_arg_fail(2)) SWIG_fail;
38137 }
38138 }
38139 {
38140 PyThreadState* __tstate = wxPyBeginAllowThreads();
38141 wxMenuItem_SetOwnerDrawn(arg1,arg2);
38142
38143 wxPyEndAllowThreads(__tstate);
38144 if (PyErr_Occurred()) SWIG_fail;
38145 }
38146 Py_INCREF(Py_None); resultobj = Py_None;
38147 return resultobj;
38148 fail:
38149 return NULL;
38150 }
38151
38152
38153 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38154 PyObject *resultobj = NULL;
38155 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38156 PyObject * obj0 = 0 ;
38157 char *kwnames[] = {
38158 (char *) "self", NULL
38159 };
38160
38161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38163 if (SWIG_arg_fail(1)) SWIG_fail;
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 wxMenuItem_ResetOwnerDrawn(arg1);
38167
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 Py_INCREF(Py_None); resultobj = Py_None;
38172 return resultobj;
38173 fail:
38174 return NULL;
38175 }
38176
38177
38178 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38179 PyObject *obj;
38180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38181 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38182 Py_INCREF(obj);
38183 return Py_BuildValue((char *)"");
38184 }
38185 static int _wrap_ControlNameStr_set(PyObject *) {
38186 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38187 return 1;
38188 }
38189
38190
38191 static PyObject *_wrap_ControlNameStr_get(void) {
38192 PyObject *pyobj = NULL;
38193
38194 {
38195 #if wxUSE_UNICODE
38196 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38197 #else
38198 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38199 #endif
38200 }
38201 return pyobj;
38202 }
38203
38204
38205 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38206 PyObject *resultobj = NULL;
38207 wxWindow *arg1 = (wxWindow *) 0 ;
38208 int arg2 = (int) -1 ;
38209 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38210 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38211 wxSize const &arg4_defvalue = wxDefaultSize ;
38212 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38213 long arg5 = (long) 0 ;
38214 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38215 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38216 wxString const &arg7_defvalue = wxPyControlNameStr ;
38217 wxString *arg7 = (wxString *) &arg7_defvalue ;
38218 wxControl *result;
38219 wxPoint temp3 ;
38220 wxSize temp4 ;
38221 bool temp7 = false ;
38222 PyObject * obj0 = 0 ;
38223 PyObject * obj1 = 0 ;
38224 PyObject * obj2 = 0 ;
38225 PyObject * obj3 = 0 ;
38226 PyObject * obj4 = 0 ;
38227 PyObject * obj5 = 0 ;
38228 PyObject * obj6 = 0 ;
38229 char *kwnames[] = {
38230 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38231 };
38232
38233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38235 if (SWIG_arg_fail(1)) SWIG_fail;
38236 if (obj1) {
38237 {
38238 arg2 = static_cast<int >(SWIG_As_int(obj1));
38239 if (SWIG_arg_fail(2)) SWIG_fail;
38240 }
38241 }
38242 if (obj2) {
38243 {
38244 arg3 = &temp3;
38245 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38246 }
38247 }
38248 if (obj3) {
38249 {
38250 arg4 = &temp4;
38251 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38252 }
38253 }
38254 if (obj4) {
38255 {
38256 arg5 = static_cast<long >(SWIG_As_long(obj4));
38257 if (SWIG_arg_fail(5)) SWIG_fail;
38258 }
38259 }
38260 if (obj5) {
38261 {
38262 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38263 if (SWIG_arg_fail(6)) SWIG_fail;
38264 if (arg6 == NULL) {
38265 SWIG_null_ref("wxValidator");
38266 }
38267 if (SWIG_arg_fail(6)) SWIG_fail;
38268 }
38269 }
38270 if (obj6) {
38271 {
38272 arg7 = wxString_in_helper(obj6);
38273 if (arg7 == NULL) SWIG_fail;
38274 temp7 = true;
38275 }
38276 }
38277 {
38278 if (!wxPyCheckForApp()) SWIG_fail;
38279 PyThreadState* __tstate = wxPyBeginAllowThreads();
38280 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38281
38282 wxPyEndAllowThreads(__tstate);
38283 if (PyErr_Occurred()) SWIG_fail;
38284 }
38285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38286 {
38287 if (temp7)
38288 delete arg7;
38289 }
38290 return resultobj;
38291 fail:
38292 {
38293 if (temp7)
38294 delete arg7;
38295 }
38296 return NULL;
38297 }
38298
38299
38300 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38301 PyObject *resultobj = NULL;
38302 wxControl *result;
38303 char *kwnames[] = {
38304 NULL
38305 };
38306
38307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38308 {
38309 if (!wxPyCheckForApp()) SWIG_fail;
38310 PyThreadState* __tstate = wxPyBeginAllowThreads();
38311 result = (wxControl *)new wxControl();
38312
38313 wxPyEndAllowThreads(__tstate);
38314 if (PyErr_Occurred()) SWIG_fail;
38315 }
38316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38317 return resultobj;
38318 fail:
38319 return NULL;
38320 }
38321
38322
38323 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38324 PyObject *resultobj = NULL;
38325 wxControl *arg1 = (wxControl *) 0 ;
38326 wxWindow *arg2 = (wxWindow *) 0 ;
38327 int arg3 = (int) -1 ;
38328 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38329 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38330 wxSize const &arg5_defvalue = wxDefaultSize ;
38331 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38332 long arg6 = (long) 0 ;
38333 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38334 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38335 wxString const &arg8_defvalue = wxPyControlNameStr ;
38336 wxString *arg8 = (wxString *) &arg8_defvalue ;
38337 bool result;
38338 wxPoint temp4 ;
38339 wxSize temp5 ;
38340 bool temp8 = false ;
38341 PyObject * obj0 = 0 ;
38342 PyObject * obj1 = 0 ;
38343 PyObject * obj2 = 0 ;
38344 PyObject * obj3 = 0 ;
38345 PyObject * obj4 = 0 ;
38346 PyObject * obj5 = 0 ;
38347 PyObject * obj6 = 0 ;
38348 PyObject * obj7 = 0 ;
38349 char *kwnames[] = {
38350 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38351 };
38352
38353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38355 if (SWIG_arg_fail(1)) SWIG_fail;
38356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38357 if (SWIG_arg_fail(2)) SWIG_fail;
38358 if (obj2) {
38359 {
38360 arg3 = static_cast<int >(SWIG_As_int(obj2));
38361 if (SWIG_arg_fail(3)) SWIG_fail;
38362 }
38363 }
38364 if (obj3) {
38365 {
38366 arg4 = &temp4;
38367 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38368 }
38369 }
38370 if (obj4) {
38371 {
38372 arg5 = &temp5;
38373 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38374 }
38375 }
38376 if (obj5) {
38377 {
38378 arg6 = static_cast<long >(SWIG_As_long(obj5));
38379 if (SWIG_arg_fail(6)) SWIG_fail;
38380 }
38381 }
38382 if (obj6) {
38383 {
38384 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38385 if (SWIG_arg_fail(7)) SWIG_fail;
38386 if (arg7 == NULL) {
38387 SWIG_null_ref("wxValidator");
38388 }
38389 if (SWIG_arg_fail(7)) SWIG_fail;
38390 }
38391 }
38392 if (obj7) {
38393 {
38394 arg8 = wxString_in_helper(obj7);
38395 if (arg8 == NULL) SWIG_fail;
38396 temp8 = true;
38397 }
38398 }
38399 {
38400 PyThreadState* __tstate = wxPyBeginAllowThreads();
38401 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38402
38403 wxPyEndAllowThreads(__tstate);
38404 if (PyErr_Occurred()) SWIG_fail;
38405 }
38406 {
38407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38408 }
38409 {
38410 if (temp8)
38411 delete arg8;
38412 }
38413 return resultobj;
38414 fail:
38415 {
38416 if (temp8)
38417 delete arg8;
38418 }
38419 return NULL;
38420 }
38421
38422
38423 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38424 PyObject *resultobj = NULL;
38425 wxControl *arg1 = (wxControl *) 0 ;
38426 wxCommandEvent *arg2 = 0 ;
38427 PyObject * obj0 = 0 ;
38428 PyObject * obj1 = 0 ;
38429 char *kwnames[] = {
38430 (char *) "self",(char *) "event", NULL
38431 };
38432
38433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38435 if (SWIG_arg_fail(1)) SWIG_fail;
38436 {
38437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38438 if (SWIG_arg_fail(2)) SWIG_fail;
38439 if (arg2 == NULL) {
38440 SWIG_null_ref("wxCommandEvent");
38441 }
38442 if (SWIG_arg_fail(2)) SWIG_fail;
38443 }
38444 {
38445 PyThreadState* __tstate = wxPyBeginAllowThreads();
38446 (arg1)->Command(*arg2);
38447
38448 wxPyEndAllowThreads(__tstate);
38449 if (PyErr_Occurred()) SWIG_fail;
38450 }
38451 Py_INCREF(Py_None); resultobj = Py_None;
38452 return resultobj;
38453 fail:
38454 return NULL;
38455 }
38456
38457
38458 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38459 PyObject *resultobj = NULL;
38460 wxControl *arg1 = (wxControl *) 0 ;
38461 wxString result;
38462 PyObject * obj0 = 0 ;
38463 char *kwnames[] = {
38464 (char *) "self", NULL
38465 };
38466
38467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38469 if (SWIG_arg_fail(1)) SWIG_fail;
38470 {
38471 PyThreadState* __tstate = wxPyBeginAllowThreads();
38472 result = (arg1)->GetLabel();
38473
38474 wxPyEndAllowThreads(__tstate);
38475 if (PyErr_Occurred()) SWIG_fail;
38476 }
38477 {
38478 #if wxUSE_UNICODE
38479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38480 #else
38481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38482 #endif
38483 }
38484 return resultobj;
38485 fail:
38486 return NULL;
38487 }
38488
38489
38490 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38491 PyObject *resultobj = NULL;
38492 wxControl *arg1 = (wxControl *) 0 ;
38493 wxString *arg2 = 0 ;
38494 bool temp2 = false ;
38495 PyObject * obj0 = 0 ;
38496 PyObject * obj1 = 0 ;
38497 char *kwnames[] = {
38498 (char *) "self",(char *) "label", NULL
38499 };
38500
38501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38503 if (SWIG_arg_fail(1)) SWIG_fail;
38504 {
38505 arg2 = wxString_in_helper(obj1);
38506 if (arg2 == NULL) SWIG_fail;
38507 temp2 = true;
38508 }
38509 {
38510 PyThreadState* __tstate = wxPyBeginAllowThreads();
38511 (arg1)->SetLabel((wxString const &)*arg2);
38512
38513 wxPyEndAllowThreads(__tstate);
38514 if (PyErr_Occurred()) SWIG_fail;
38515 }
38516 Py_INCREF(Py_None); resultobj = Py_None;
38517 {
38518 if (temp2)
38519 delete arg2;
38520 }
38521 return resultobj;
38522 fail:
38523 {
38524 if (temp2)
38525 delete arg2;
38526 }
38527 return NULL;
38528 }
38529
38530
38531 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38532 PyObject *resultobj = NULL;
38533 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38534 wxVisualAttributes result;
38535 PyObject * obj0 = 0 ;
38536 char *kwnames[] = {
38537 (char *) "variant", NULL
38538 };
38539
38540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38541 if (obj0) {
38542 {
38543 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38544 if (SWIG_arg_fail(1)) SWIG_fail;
38545 }
38546 }
38547 {
38548 if (!wxPyCheckForApp()) SWIG_fail;
38549 PyThreadState* __tstate = wxPyBeginAllowThreads();
38550 result = wxControl::GetClassDefaultAttributes(arg1);
38551
38552 wxPyEndAllowThreads(__tstate);
38553 if (PyErr_Occurred()) SWIG_fail;
38554 }
38555 {
38556 wxVisualAttributes * resultptr;
38557 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38558 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38559 }
38560 return resultobj;
38561 fail:
38562 return NULL;
38563 }
38564
38565
38566 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38567 PyObject *obj;
38568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38569 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38570 Py_INCREF(obj);
38571 return Py_BuildValue((char *)"");
38572 }
38573 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38574 PyObject *resultobj = NULL;
38575 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38576 wxString *arg2 = 0 ;
38577 PyObject *arg3 = (PyObject *) NULL ;
38578 int result;
38579 bool temp2 = false ;
38580 PyObject * obj0 = 0 ;
38581 PyObject * obj1 = 0 ;
38582 PyObject * obj2 = 0 ;
38583 char *kwnames[] = {
38584 (char *) "self",(char *) "item",(char *) "clientData", NULL
38585 };
38586
38587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38589 if (SWIG_arg_fail(1)) SWIG_fail;
38590 {
38591 arg2 = wxString_in_helper(obj1);
38592 if (arg2 == NULL) SWIG_fail;
38593 temp2 = true;
38594 }
38595 if (obj2) {
38596 arg3 = obj2;
38597 }
38598 {
38599 PyThreadState* __tstate = wxPyBeginAllowThreads();
38600 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38601
38602 wxPyEndAllowThreads(__tstate);
38603 if (PyErr_Occurred()) SWIG_fail;
38604 }
38605 {
38606 resultobj = SWIG_From_int(static_cast<int >(result));
38607 }
38608 {
38609 if (temp2)
38610 delete arg2;
38611 }
38612 return resultobj;
38613 fail:
38614 {
38615 if (temp2)
38616 delete arg2;
38617 }
38618 return NULL;
38619 }
38620
38621
38622 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38623 PyObject *resultobj = NULL;
38624 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38625 wxArrayString *arg2 = 0 ;
38626 bool temp2 = false ;
38627 PyObject * obj0 = 0 ;
38628 PyObject * obj1 = 0 ;
38629 char *kwnames[] = {
38630 (char *) "self",(char *) "strings", NULL
38631 };
38632
38633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38635 if (SWIG_arg_fail(1)) SWIG_fail;
38636 {
38637 if (! PySequence_Check(obj1)) {
38638 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38639 SWIG_fail;
38640 }
38641 arg2 = new wxArrayString;
38642 temp2 = true;
38643 int i, len=PySequence_Length(obj1);
38644 for (i=0; i<len; i++) {
38645 PyObject* item = PySequence_GetItem(obj1, i);
38646 wxString* s = wxString_in_helper(item);
38647 if (PyErr_Occurred()) SWIG_fail;
38648 arg2->Add(*s);
38649 delete s;
38650 Py_DECREF(item);
38651 }
38652 }
38653 {
38654 PyThreadState* __tstate = wxPyBeginAllowThreads();
38655 (arg1)->Append((wxArrayString const &)*arg2);
38656
38657 wxPyEndAllowThreads(__tstate);
38658 if (PyErr_Occurred()) SWIG_fail;
38659 }
38660 Py_INCREF(Py_None); resultobj = Py_None;
38661 {
38662 if (temp2) delete arg2;
38663 }
38664 return resultobj;
38665 fail:
38666 {
38667 if (temp2) delete arg2;
38668 }
38669 return NULL;
38670 }
38671
38672
38673 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38674 PyObject *resultobj = NULL;
38675 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38676 wxString *arg2 = 0 ;
38677 int arg3 ;
38678 PyObject *arg4 = (PyObject *) NULL ;
38679 int result;
38680 bool temp2 = false ;
38681 PyObject * obj0 = 0 ;
38682 PyObject * obj1 = 0 ;
38683 PyObject * obj2 = 0 ;
38684 PyObject * obj3 = 0 ;
38685 char *kwnames[] = {
38686 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38687 };
38688
38689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38691 if (SWIG_arg_fail(1)) SWIG_fail;
38692 {
38693 arg2 = wxString_in_helper(obj1);
38694 if (arg2 == NULL) SWIG_fail;
38695 temp2 = true;
38696 }
38697 {
38698 arg3 = static_cast<int >(SWIG_As_int(obj2));
38699 if (SWIG_arg_fail(3)) SWIG_fail;
38700 }
38701 if (obj3) {
38702 arg4 = obj3;
38703 }
38704 {
38705 PyThreadState* __tstate = wxPyBeginAllowThreads();
38706 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38707
38708 wxPyEndAllowThreads(__tstate);
38709 if (PyErr_Occurred()) SWIG_fail;
38710 }
38711 {
38712 resultobj = SWIG_From_int(static_cast<int >(result));
38713 }
38714 {
38715 if (temp2)
38716 delete arg2;
38717 }
38718 return resultobj;
38719 fail:
38720 {
38721 if (temp2)
38722 delete arg2;
38723 }
38724 return NULL;
38725 }
38726
38727
38728 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38729 PyObject *resultobj = NULL;
38730 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38731 PyObject * obj0 = 0 ;
38732 char *kwnames[] = {
38733 (char *) "self", NULL
38734 };
38735
38736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38738 if (SWIG_arg_fail(1)) SWIG_fail;
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 (arg1)->Clear();
38742
38743 wxPyEndAllowThreads(__tstate);
38744 if (PyErr_Occurred()) SWIG_fail;
38745 }
38746 Py_INCREF(Py_None); resultobj = Py_None;
38747 return resultobj;
38748 fail:
38749 return NULL;
38750 }
38751
38752
38753 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38754 PyObject *resultobj = NULL;
38755 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38756 int arg2 ;
38757 PyObject * obj0 = 0 ;
38758 PyObject * obj1 = 0 ;
38759 char *kwnames[] = {
38760 (char *) "self",(char *) "n", NULL
38761 };
38762
38763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38765 if (SWIG_arg_fail(1)) SWIG_fail;
38766 {
38767 arg2 = static_cast<int >(SWIG_As_int(obj1));
38768 if (SWIG_arg_fail(2)) SWIG_fail;
38769 }
38770 {
38771 PyThreadState* __tstate = wxPyBeginAllowThreads();
38772 (arg1)->Delete(arg2);
38773
38774 wxPyEndAllowThreads(__tstate);
38775 if (PyErr_Occurred()) SWIG_fail;
38776 }
38777 Py_INCREF(Py_None); resultobj = Py_None;
38778 return resultobj;
38779 fail:
38780 return NULL;
38781 }
38782
38783
38784 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38785 PyObject *resultobj = NULL;
38786 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38787 int arg2 ;
38788 PyObject *result;
38789 PyObject * obj0 = 0 ;
38790 PyObject * obj1 = 0 ;
38791 char *kwnames[] = {
38792 (char *) "self",(char *) "n", NULL
38793 };
38794
38795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38797 if (SWIG_arg_fail(1)) SWIG_fail;
38798 {
38799 arg2 = static_cast<int >(SWIG_As_int(obj1));
38800 if (SWIG_arg_fail(2)) SWIG_fail;
38801 }
38802 {
38803 PyThreadState* __tstate = wxPyBeginAllowThreads();
38804 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38805
38806 wxPyEndAllowThreads(__tstate);
38807 if (PyErr_Occurred()) SWIG_fail;
38808 }
38809 resultobj = result;
38810 return resultobj;
38811 fail:
38812 return NULL;
38813 }
38814
38815
38816 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38817 PyObject *resultobj = NULL;
38818 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38819 int arg2 ;
38820 PyObject *arg3 = (PyObject *) 0 ;
38821 PyObject * obj0 = 0 ;
38822 PyObject * obj1 = 0 ;
38823 PyObject * obj2 = 0 ;
38824 char *kwnames[] = {
38825 (char *) "self",(char *) "n",(char *) "clientData", NULL
38826 };
38827
38828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38830 if (SWIG_arg_fail(1)) SWIG_fail;
38831 {
38832 arg2 = static_cast<int >(SWIG_As_int(obj1));
38833 if (SWIG_arg_fail(2)) SWIG_fail;
38834 }
38835 arg3 = obj2;
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 wxItemContainer_SetClientData(arg1,arg2,arg3);
38839
38840 wxPyEndAllowThreads(__tstate);
38841 if (PyErr_Occurred()) SWIG_fail;
38842 }
38843 Py_INCREF(Py_None); resultobj = Py_None;
38844 return resultobj;
38845 fail:
38846 return NULL;
38847 }
38848
38849
38850 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38851 PyObject *resultobj = NULL;
38852 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38853 int result;
38854 PyObject * obj0 = 0 ;
38855 char *kwnames[] = {
38856 (char *) "self", NULL
38857 };
38858
38859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38861 if (SWIG_arg_fail(1)) SWIG_fail;
38862 {
38863 PyThreadState* __tstate = wxPyBeginAllowThreads();
38864 result = (int)((wxItemContainer const *)arg1)->GetCount();
38865
38866 wxPyEndAllowThreads(__tstate);
38867 if (PyErr_Occurred()) SWIG_fail;
38868 }
38869 {
38870 resultobj = SWIG_From_int(static_cast<int >(result));
38871 }
38872 return resultobj;
38873 fail:
38874 return NULL;
38875 }
38876
38877
38878 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38879 PyObject *resultobj = NULL;
38880 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38881 bool result;
38882 PyObject * obj0 = 0 ;
38883 char *kwnames[] = {
38884 (char *) "self", NULL
38885 };
38886
38887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38889 if (SWIG_arg_fail(1)) SWIG_fail;
38890 {
38891 PyThreadState* __tstate = wxPyBeginAllowThreads();
38892 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38893
38894 wxPyEndAllowThreads(__tstate);
38895 if (PyErr_Occurred()) SWIG_fail;
38896 }
38897 {
38898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38899 }
38900 return resultobj;
38901 fail:
38902 return NULL;
38903 }
38904
38905
38906 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38907 PyObject *resultobj = NULL;
38908 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38909 int arg2 ;
38910 wxString result;
38911 PyObject * obj0 = 0 ;
38912 PyObject * obj1 = 0 ;
38913 char *kwnames[] = {
38914 (char *) "self",(char *) "n", NULL
38915 };
38916
38917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38919 if (SWIG_arg_fail(1)) SWIG_fail;
38920 {
38921 arg2 = static_cast<int >(SWIG_As_int(obj1));
38922 if (SWIG_arg_fail(2)) SWIG_fail;
38923 }
38924 {
38925 PyThreadState* __tstate = wxPyBeginAllowThreads();
38926 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38927
38928 wxPyEndAllowThreads(__tstate);
38929 if (PyErr_Occurred()) SWIG_fail;
38930 }
38931 {
38932 #if wxUSE_UNICODE
38933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38934 #else
38935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38936 #endif
38937 }
38938 return resultobj;
38939 fail:
38940 return NULL;
38941 }
38942
38943
38944 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38945 PyObject *resultobj = NULL;
38946 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38947 wxArrayString result;
38948 PyObject * obj0 = 0 ;
38949 char *kwnames[] = {
38950 (char *) "self", NULL
38951 };
38952
38953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38955 if (SWIG_arg_fail(1)) SWIG_fail;
38956 {
38957 PyThreadState* __tstate = wxPyBeginAllowThreads();
38958 result = ((wxItemContainer const *)arg1)->GetStrings();
38959
38960 wxPyEndAllowThreads(__tstate);
38961 if (PyErr_Occurred()) SWIG_fail;
38962 }
38963 {
38964 resultobj = wxArrayString2PyList_helper(result);
38965 }
38966 return resultobj;
38967 fail:
38968 return NULL;
38969 }
38970
38971
38972 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38973 PyObject *resultobj = NULL;
38974 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38975 int arg2 ;
38976 wxString *arg3 = 0 ;
38977 bool temp3 = false ;
38978 PyObject * obj0 = 0 ;
38979 PyObject * obj1 = 0 ;
38980 PyObject * obj2 = 0 ;
38981 char *kwnames[] = {
38982 (char *) "self",(char *) "n",(char *) "s", NULL
38983 };
38984
38985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38987 if (SWIG_arg_fail(1)) SWIG_fail;
38988 {
38989 arg2 = static_cast<int >(SWIG_As_int(obj1));
38990 if (SWIG_arg_fail(2)) SWIG_fail;
38991 }
38992 {
38993 arg3 = wxString_in_helper(obj2);
38994 if (arg3 == NULL) SWIG_fail;
38995 temp3 = true;
38996 }
38997 {
38998 PyThreadState* __tstate = wxPyBeginAllowThreads();
38999 (arg1)->SetString(arg2,(wxString const &)*arg3);
39000
39001 wxPyEndAllowThreads(__tstate);
39002 if (PyErr_Occurred()) SWIG_fail;
39003 }
39004 Py_INCREF(Py_None); resultobj = Py_None;
39005 {
39006 if (temp3)
39007 delete arg3;
39008 }
39009 return resultobj;
39010 fail:
39011 {
39012 if (temp3)
39013 delete arg3;
39014 }
39015 return NULL;
39016 }
39017
39018
39019 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39020 PyObject *resultobj = NULL;
39021 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39022 wxString *arg2 = 0 ;
39023 int result;
39024 bool temp2 = false ;
39025 PyObject * obj0 = 0 ;
39026 PyObject * obj1 = 0 ;
39027 char *kwnames[] = {
39028 (char *) "self",(char *) "s", NULL
39029 };
39030
39031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39033 if (SWIG_arg_fail(1)) SWIG_fail;
39034 {
39035 arg2 = wxString_in_helper(obj1);
39036 if (arg2 == NULL) SWIG_fail;
39037 temp2 = true;
39038 }
39039 {
39040 PyThreadState* __tstate = wxPyBeginAllowThreads();
39041 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39042
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 {
39047 resultobj = SWIG_From_int(static_cast<int >(result));
39048 }
39049 {
39050 if (temp2)
39051 delete arg2;
39052 }
39053 return resultobj;
39054 fail:
39055 {
39056 if (temp2)
39057 delete arg2;
39058 }
39059 return NULL;
39060 }
39061
39062
39063 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39064 PyObject *resultobj = NULL;
39065 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39066 int arg2 ;
39067 PyObject * obj0 = 0 ;
39068 PyObject * obj1 = 0 ;
39069 char *kwnames[] = {
39070 (char *) "self",(char *) "n", NULL
39071 };
39072
39073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39075 if (SWIG_arg_fail(1)) SWIG_fail;
39076 {
39077 arg2 = static_cast<int >(SWIG_As_int(obj1));
39078 if (SWIG_arg_fail(2)) SWIG_fail;
39079 }
39080 {
39081 PyThreadState* __tstate = wxPyBeginAllowThreads();
39082 (arg1)->SetSelection(arg2);
39083
39084 wxPyEndAllowThreads(__tstate);
39085 if (PyErr_Occurred()) SWIG_fail;
39086 }
39087 Py_INCREF(Py_None); resultobj = Py_None;
39088 return resultobj;
39089 fail:
39090 return NULL;
39091 }
39092
39093
39094 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39095 PyObject *resultobj = NULL;
39096 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39097 int result;
39098 PyObject * obj0 = 0 ;
39099 char *kwnames[] = {
39100 (char *) "self", NULL
39101 };
39102
39103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39105 if (SWIG_arg_fail(1)) SWIG_fail;
39106 {
39107 PyThreadState* __tstate = wxPyBeginAllowThreads();
39108 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39109
39110 wxPyEndAllowThreads(__tstate);
39111 if (PyErr_Occurred()) SWIG_fail;
39112 }
39113 {
39114 resultobj = SWIG_From_int(static_cast<int >(result));
39115 }
39116 return resultobj;
39117 fail:
39118 return NULL;
39119 }
39120
39121
39122 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39123 PyObject *resultobj = NULL;
39124 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39125 wxString *arg2 = 0 ;
39126 bool result;
39127 bool temp2 = false ;
39128 PyObject * obj0 = 0 ;
39129 PyObject * obj1 = 0 ;
39130 char *kwnames[] = {
39131 (char *) "self",(char *) "s", NULL
39132 };
39133
39134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
39135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39136 if (SWIG_arg_fail(1)) SWIG_fail;
39137 {
39138 arg2 = wxString_in_helper(obj1);
39139 if (arg2 == NULL) SWIG_fail;
39140 temp2 = true;
39141 }
39142 {
39143 PyThreadState* __tstate = wxPyBeginAllowThreads();
39144 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39145
39146 wxPyEndAllowThreads(__tstate);
39147 if (PyErr_Occurred()) SWIG_fail;
39148 }
39149 {
39150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39151 }
39152 {
39153 if (temp2)
39154 delete arg2;
39155 }
39156 return resultobj;
39157 fail:
39158 {
39159 if (temp2)
39160 delete arg2;
39161 }
39162 return NULL;
39163 }
39164
39165
39166 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39167 PyObject *resultobj = NULL;
39168 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39169 wxString result;
39170 PyObject * obj0 = 0 ;
39171 char *kwnames[] = {
39172 (char *) "self", NULL
39173 };
39174
39175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39177 if (SWIG_arg_fail(1)) SWIG_fail;
39178 {
39179 PyThreadState* __tstate = wxPyBeginAllowThreads();
39180 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39181
39182 wxPyEndAllowThreads(__tstate);
39183 if (PyErr_Occurred()) SWIG_fail;
39184 }
39185 {
39186 #if wxUSE_UNICODE
39187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39188 #else
39189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39190 #endif
39191 }
39192 return resultobj;
39193 fail:
39194 return NULL;
39195 }
39196
39197
39198 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39199 PyObject *resultobj = NULL;
39200 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39201 int arg2 ;
39202 PyObject * obj0 = 0 ;
39203 PyObject * obj1 = 0 ;
39204 char *kwnames[] = {
39205 (char *) "self",(char *) "n", NULL
39206 };
39207
39208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39210 if (SWIG_arg_fail(1)) SWIG_fail;
39211 {
39212 arg2 = static_cast<int >(SWIG_As_int(obj1));
39213 if (SWIG_arg_fail(2)) SWIG_fail;
39214 }
39215 {
39216 PyThreadState* __tstate = wxPyBeginAllowThreads();
39217 (arg1)->Select(arg2);
39218
39219 wxPyEndAllowThreads(__tstate);
39220 if (PyErr_Occurred()) SWIG_fail;
39221 }
39222 Py_INCREF(Py_None); resultobj = Py_None;
39223 return resultobj;
39224 fail:
39225 return NULL;
39226 }
39227
39228
39229 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39230 PyObject *obj;
39231 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39232 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39233 Py_INCREF(obj);
39234 return Py_BuildValue((char *)"");
39235 }
39236 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39237 PyObject *obj;
39238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39239 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39240 Py_INCREF(obj);
39241 return Py_BuildValue((char *)"");
39242 }
39243 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39244 PyObject *resultobj = NULL;
39245 wxSizerItem *result;
39246 char *kwnames[] = {
39247 NULL
39248 };
39249
39250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39251 {
39252 PyThreadState* __tstate = wxPyBeginAllowThreads();
39253 result = (wxSizerItem *)new wxSizerItem();
39254
39255 wxPyEndAllowThreads(__tstate);
39256 if (PyErr_Occurred()) SWIG_fail;
39257 }
39258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39259 return resultobj;
39260 fail:
39261 return NULL;
39262 }
39263
39264
39265 static PyObject *_wrap_delete_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39266 PyObject *resultobj = NULL;
39267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39268 PyObject * obj0 = 0 ;
39269 char *kwnames[] = {
39270 (char *) "self", NULL
39271 };
39272
39273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SizerItem",kwnames,&obj0)) goto fail;
39274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39275 if (SWIG_arg_fail(1)) SWIG_fail;
39276 {
39277 PyThreadState* __tstate = wxPyBeginAllowThreads();
39278 delete arg1;
39279
39280 wxPyEndAllowThreads(__tstate);
39281 if (PyErr_Occurred()) SWIG_fail;
39282 }
39283 Py_INCREF(Py_None); resultobj = Py_None;
39284 return resultobj;
39285 fail:
39286 return NULL;
39287 }
39288
39289
39290 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39291 PyObject *resultobj = NULL;
39292 wxWindow *arg1 = (wxWindow *) 0 ;
39293 int arg2 ;
39294 int arg3 ;
39295 int arg4 ;
39296 PyObject *arg5 = (PyObject *) NULL ;
39297 wxSizerItem *result;
39298 PyObject * obj0 = 0 ;
39299 PyObject * obj1 = 0 ;
39300 PyObject * obj2 = 0 ;
39301 PyObject * obj3 = 0 ;
39302 PyObject * obj4 = 0 ;
39303 char *kwnames[] = {
39304 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39305 };
39306
39307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39309 if (SWIG_arg_fail(1)) SWIG_fail;
39310 {
39311 arg2 = static_cast<int >(SWIG_As_int(obj1));
39312 if (SWIG_arg_fail(2)) SWIG_fail;
39313 }
39314 {
39315 arg3 = static_cast<int >(SWIG_As_int(obj2));
39316 if (SWIG_arg_fail(3)) SWIG_fail;
39317 }
39318 {
39319 arg4 = static_cast<int >(SWIG_As_int(obj3));
39320 if (SWIG_arg_fail(4)) SWIG_fail;
39321 }
39322 if (obj4) {
39323 arg5 = obj4;
39324 }
39325 {
39326 PyThreadState* __tstate = wxPyBeginAllowThreads();
39327 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39328
39329 wxPyEndAllowThreads(__tstate);
39330 if (PyErr_Occurred()) SWIG_fail;
39331 }
39332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39333 return resultobj;
39334 fail:
39335 return NULL;
39336 }
39337
39338
39339 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39340 PyObject *resultobj = NULL;
39341 int arg1 ;
39342 int arg2 ;
39343 int arg3 ;
39344 int arg4 ;
39345 int arg5 ;
39346 PyObject *arg6 = (PyObject *) NULL ;
39347 wxSizerItem *result;
39348 PyObject * obj0 = 0 ;
39349 PyObject * obj1 = 0 ;
39350 PyObject * obj2 = 0 ;
39351 PyObject * obj3 = 0 ;
39352 PyObject * obj4 = 0 ;
39353 PyObject * obj5 = 0 ;
39354 char *kwnames[] = {
39355 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39356 };
39357
39358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39359 {
39360 arg1 = static_cast<int >(SWIG_As_int(obj0));
39361 if (SWIG_arg_fail(1)) SWIG_fail;
39362 }
39363 {
39364 arg2 = static_cast<int >(SWIG_As_int(obj1));
39365 if (SWIG_arg_fail(2)) SWIG_fail;
39366 }
39367 {
39368 arg3 = static_cast<int >(SWIG_As_int(obj2));
39369 if (SWIG_arg_fail(3)) SWIG_fail;
39370 }
39371 {
39372 arg4 = static_cast<int >(SWIG_As_int(obj3));
39373 if (SWIG_arg_fail(4)) SWIG_fail;
39374 }
39375 {
39376 arg5 = static_cast<int >(SWIG_As_int(obj4));
39377 if (SWIG_arg_fail(5)) SWIG_fail;
39378 }
39379 if (obj5) {
39380 arg6 = obj5;
39381 }
39382 {
39383 PyThreadState* __tstate = wxPyBeginAllowThreads();
39384 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39385
39386 wxPyEndAllowThreads(__tstate);
39387 if (PyErr_Occurred()) SWIG_fail;
39388 }
39389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39390 return resultobj;
39391 fail:
39392 return NULL;
39393 }
39394
39395
39396 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39397 PyObject *resultobj = NULL;
39398 wxSizer *arg1 = (wxSizer *) 0 ;
39399 int arg2 ;
39400 int arg3 ;
39401 int arg4 ;
39402 PyObject *arg5 = (PyObject *) NULL ;
39403 wxSizerItem *result;
39404 PyObject * obj0 = 0 ;
39405 PyObject * obj1 = 0 ;
39406 PyObject * obj2 = 0 ;
39407 PyObject * obj3 = 0 ;
39408 PyObject * obj4 = 0 ;
39409 char *kwnames[] = {
39410 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39411 };
39412
39413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
39415 if (SWIG_arg_fail(1)) SWIG_fail;
39416 {
39417 arg2 = static_cast<int >(SWIG_As_int(obj1));
39418 if (SWIG_arg_fail(2)) SWIG_fail;
39419 }
39420 {
39421 arg3 = static_cast<int >(SWIG_As_int(obj2));
39422 if (SWIG_arg_fail(3)) SWIG_fail;
39423 }
39424 {
39425 arg4 = static_cast<int >(SWIG_As_int(obj3));
39426 if (SWIG_arg_fail(4)) SWIG_fail;
39427 }
39428 if (obj4) {
39429 arg5 = obj4;
39430 }
39431 {
39432 PyThreadState* __tstate = wxPyBeginAllowThreads();
39433 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39434
39435 wxPyEndAllowThreads(__tstate);
39436 if (PyErr_Occurred()) SWIG_fail;
39437 }
39438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39439 return resultobj;
39440 fail:
39441 return NULL;
39442 }
39443
39444
39445 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39446 PyObject *resultobj = NULL;
39447 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39448 PyObject * obj0 = 0 ;
39449 char *kwnames[] = {
39450 (char *) "self", NULL
39451 };
39452
39453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39455 if (SWIG_arg_fail(1)) SWIG_fail;
39456 {
39457 PyThreadState* __tstate = wxPyBeginAllowThreads();
39458 (arg1)->DeleteWindows();
39459
39460 wxPyEndAllowThreads(__tstate);
39461 if (PyErr_Occurred()) SWIG_fail;
39462 }
39463 Py_INCREF(Py_None); resultobj = Py_None;
39464 return resultobj;
39465 fail:
39466 return NULL;
39467 }
39468
39469
39470 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39471 PyObject *resultobj = NULL;
39472 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39473 PyObject * obj0 = 0 ;
39474 char *kwnames[] = {
39475 (char *) "self", NULL
39476 };
39477
39478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39480 if (SWIG_arg_fail(1)) SWIG_fail;
39481 {
39482 PyThreadState* __tstate = wxPyBeginAllowThreads();
39483 (arg1)->DetachSizer();
39484
39485 wxPyEndAllowThreads(__tstate);
39486 if (PyErr_Occurred()) SWIG_fail;
39487 }
39488 Py_INCREF(Py_None); resultobj = Py_None;
39489 return resultobj;
39490 fail:
39491 return NULL;
39492 }
39493
39494
39495 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39496 PyObject *resultobj = NULL;
39497 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39498 wxSize result;
39499 PyObject * obj0 = 0 ;
39500 char *kwnames[] = {
39501 (char *) "self", NULL
39502 };
39503
39504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39506 if (SWIG_arg_fail(1)) SWIG_fail;
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 result = (arg1)->GetSize();
39510
39511 wxPyEndAllowThreads(__tstate);
39512 if (PyErr_Occurred()) SWIG_fail;
39513 }
39514 {
39515 wxSize * resultptr;
39516 resultptr = new wxSize(static_cast<wxSize & >(result));
39517 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39518 }
39519 return resultobj;
39520 fail:
39521 return NULL;
39522 }
39523
39524
39525 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39526 PyObject *resultobj = NULL;
39527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39528 wxSize result;
39529 PyObject * obj0 = 0 ;
39530 char *kwnames[] = {
39531 (char *) "self", NULL
39532 };
39533
39534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39536 if (SWIG_arg_fail(1)) SWIG_fail;
39537 {
39538 PyThreadState* __tstate = wxPyBeginAllowThreads();
39539 result = (arg1)->CalcMin();
39540
39541 wxPyEndAllowThreads(__tstate);
39542 if (PyErr_Occurred()) SWIG_fail;
39543 }
39544 {
39545 wxSize * resultptr;
39546 resultptr = new wxSize(static_cast<wxSize & >(result));
39547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39548 }
39549 return resultobj;
39550 fail:
39551 return NULL;
39552 }
39553
39554
39555 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39556 PyObject *resultobj = NULL;
39557 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39558 wxPoint *arg2 = 0 ;
39559 wxSize *arg3 = 0 ;
39560 wxPoint temp2 ;
39561 wxSize temp3 ;
39562 PyObject * obj0 = 0 ;
39563 PyObject * obj1 = 0 ;
39564 PyObject * obj2 = 0 ;
39565 char *kwnames[] = {
39566 (char *) "self",(char *) "pos",(char *) "size", NULL
39567 };
39568
39569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39571 if (SWIG_arg_fail(1)) SWIG_fail;
39572 {
39573 arg2 = &temp2;
39574 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39575 }
39576 {
39577 arg3 = &temp3;
39578 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39579 }
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
39583
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 Py_INCREF(Py_None); resultobj = Py_None;
39588 return resultobj;
39589 fail:
39590 return NULL;
39591 }
39592
39593
39594 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj = NULL;
39596 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39597 wxSize result;
39598 PyObject * obj0 = 0 ;
39599 char *kwnames[] = {
39600 (char *) "self", NULL
39601 };
39602
39603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39605 if (SWIG_arg_fail(1)) SWIG_fail;
39606 {
39607 PyThreadState* __tstate = wxPyBeginAllowThreads();
39608 result = (arg1)->GetMinSize();
39609
39610 wxPyEndAllowThreads(__tstate);
39611 if (PyErr_Occurred()) SWIG_fail;
39612 }
39613 {
39614 wxSize * resultptr;
39615 resultptr = new wxSize(static_cast<wxSize & >(result));
39616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39617 }
39618 return resultobj;
39619 fail:
39620 return NULL;
39621 }
39622
39623
39624 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39625 PyObject *resultobj = NULL;
39626 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39627 wxSize result;
39628 PyObject * obj0 = 0 ;
39629 char *kwnames[] = {
39630 (char *) "self", NULL
39631 };
39632
39633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39635 if (SWIG_arg_fail(1)) SWIG_fail;
39636 {
39637 PyThreadState* __tstate = wxPyBeginAllowThreads();
39638 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39639
39640 wxPyEndAllowThreads(__tstate);
39641 if (PyErr_Occurred()) SWIG_fail;
39642 }
39643 {
39644 wxSize * resultptr;
39645 resultptr = new wxSize(static_cast<wxSize & >(result));
39646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39647 }
39648 return resultobj;
39649 fail:
39650 return NULL;
39651 }
39652
39653
39654 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39655 PyObject *resultobj = NULL;
39656 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39657 int arg2 ;
39658 int arg3 ;
39659 PyObject * obj0 = 0 ;
39660 PyObject * obj1 = 0 ;
39661 PyObject * obj2 = 0 ;
39662 char *kwnames[] = {
39663 (char *) "self",(char *) "x",(char *) "y", NULL
39664 };
39665
39666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39668 if (SWIG_arg_fail(1)) SWIG_fail;
39669 {
39670 arg2 = static_cast<int >(SWIG_As_int(obj1));
39671 if (SWIG_arg_fail(2)) SWIG_fail;
39672 }
39673 {
39674 arg3 = static_cast<int >(SWIG_As_int(obj2));
39675 if (SWIG_arg_fail(3)) SWIG_fail;
39676 }
39677 {
39678 PyThreadState* __tstate = wxPyBeginAllowThreads();
39679 (arg1)->SetInitSize(arg2,arg3);
39680
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 Py_INCREF(Py_None); resultobj = Py_None;
39685 return resultobj;
39686 fail:
39687 return NULL;
39688 }
39689
39690
39691 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39692 PyObject *resultobj = NULL;
39693 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39694 int arg2 ;
39695 int arg3 ;
39696 PyObject * obj0 = 0 ;
39697 PyObject * obj1 = 0 ;
39698 PyObject * obj2 = 0 ;
39699 char *kwnames[] = {
39700 (char *) "self",(char *) "width",(char *) "height", NULL
39701 };
39702
39703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39705 if (SWIG_arg_fail(1)) SWIG_fail;
39706 {
39707 arg2 = static_cast<int >(SWIG_As_int(obj1));
39708 if (SWIG_arg_fail(2)) SWIG_fail;
39709 }
39710 {
39711 arg3 = static_cast<int >(SWIG_As_int(obj2));
39712 if (SWIG_arg_fail(3)) SWIG_fail;
39713 }
39714 {
39715 PyThreadState* __tstate = wxPyBeginAllowThreads();
39716 (arg1)->SetRatio(arg2,arg3);
39717
39718 wxPyEndAllowThreads(__tstate);
39719 if (PyErr_Occurred()) SWIG_fail;
39720 }
39721 Py_INCREF(Py_None); resultobj = Py_None;
39722 return resultobj;
39723 fail:
39724 return NULL;
39725 }
39726
39727
39728 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39729 PyObject *resultobj = NULL;
39730 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39731 wxSize *arg2 = 0 ;
39732 wxSize temp2 ;
39733 PyObject * obj0 = 0 ;
39734 PyObject * obj1 = 0 ;
39735 char *kwnames[] = {
39736 (char *) "self",(char *) "size", NULL
39737 };
39738
39739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39741 if (SWIG_arg_fail(1)) SWIG_fail;
39742 {
39743 arg2 = &temp2;
39744 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39745 }
39746 {
39747 PyThreadState* __tstate = wxPyBeginAllowThreads();
39748 (arg1)->SetRatio((wxSize const &)*arg2);
39749
39750 wxPyEndAllowThreads(__tstate);
39751 if (PyErr_Occurred()) SWIG_fail;
39752 }
39753 Py_INCREF(Py_None); resultobj = Py_None;
39754 return resultobj;
39755 fail:
39756 return NULL;
39757 }
39758
39759
39760 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39761 PyObject *resultobj = NULL;
39762 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39763 float arg2 ;
39764 PyObject * obj0 = 0 ;
39765 PyObject * obj1 = 0 ;
39766 char *kwnames[] = {
39767 (char *) "self",(char *) "ratio", NULL
39768 };
39769
39770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39772 if (SWIG_arg_fail(1)) SWIG_fail;
39773 {
39774 arg2 = static_cast<float >(SWIG_As_float(obj1));
39775 if (SWIG_arg_fail(2)) SWIG_fail;
39776 }
39777 {
39778 PyThreadState* __tstate = wxPyBeginAllowThreads();
39779 (arg1)->SetRatio(arg2);
39780
39781 wxPyEndAllowThreads(__tstate);
39782 if (PyErr_Occurred()) SWIG_fail;
39783 }
39784 Py_INCREF(Py_None); resultobj = Py_None;
39785 return resultobj;
39786 fail:
39787 return NULL;
39788 }
39789
39790
39791 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39792 PyObject *resultobj = NULL;
39793 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39794 float result;
39795 PyObject * obj0 = 0 ;
39796 char *kwnames[] = {
39797 (char *) "self", NULL
39798 };
39799
39800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39802 if (SWIG_arg_fail(1)) SWIG_fail;
39803 {
39804 PyThreadState* __tstate = wxPyBeginAllowThreads();
39805 result = (float)(arg1)->GetRatio();
39806
39807 wxPyEndAllowThreads(__tstate);
39808 if (PyErr_Occurred()) SWIG_fail;
39809 }
39810 {
39811 resultobj = SWIG_From_float(static_cast<float >(result));
39812 }
39813 return resultobj;
39814 fail:
39815 return NULL;
39816 }
39817
39818
39819 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39820 PyObject *resultobj = NULL;
39821 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39822 wxRect result;
39823 PyObject * obj0 = 0 ;
39824 char *kwnames[] = {
39825 (char *) "self", NULL
39826 };
39827
39828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39830 if (SWIG_arg_fail(1)) SWIG_fail;
39831 {
39832 PyThreadState* __tstate = wxPyBeginAllowThreads();
39833 result = (arg1)->GetRect();
39834
39835 wxPyEndAllowThreads(__tstate);
39836 if (PyErr_Occurred()) SWIG_fail;
39837 }
39838 {
39839 wxRect * resultptr;
39840 resultptr = new wxRect(static_cast<wxRect & >(result));
39841 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39842 }
39843 return resultobj;
39844 fail:
39845 return NULL;
39846 }
39847
39848
39849 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39850 PyObject *resultobj = NULL;
39851 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39852 bool result;
39853 PyObject * obj0 = 0 ;
39854 char *kwnames[] = {
39855 (char *) "self", NULL
39856 };
39857
39858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39860 if (SWIG_arg_fail(1)) SWIG_fail;
39861 {
39862 PyThreadState* __tstate = wxPyBeginAllowThreads();
39863 result = (bool)(arg1)->IsWindow();
39864
39865 wxPyEndAllowThreads(__tstate);
39866 if (PyErr_Occurred()) SWIG_fail;
39867 }
39868 {
39869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39870 }
39871 return resultobj;
39872 fail:
39873 return NULL;
39874 }
39875
39876
39877 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39878 PyObject *resultobj = NULL;
39879 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39880 bool result;
39881 PyObject * obj0 = 0 ;
39882 char *kwnames[] = {
39883 (char *) "self", NULL
39884 };
39885
39886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39888 if (SWIG_arg_fail(1)) SWIG_fail;
39889 {
39890 PyThreadState* __tstate = wxPyBeginAllowThreads();
39891 result = (bool)(arg1)->IsSizer();
39892
39893 wxPyEndAllowThreads(__tstate);
39894 if (PyErr_Occurred()) SWIG_fail;
39895 }
39896 {
39897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39898 }
39899 return resultobj;
39900 fail:
39901 return NULL;
39902 }
39903
39904
39905 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39906 PyObject *resultobj = NULL;
39907 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39908 bool result;
39909 PyObject * obj0 = 0 ;
39910 char *kwnames[] = {
39911 (char *) "self", NULL
39912 };
39913
39914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39916 if (SWIG_arg_fail(1)) SWIG_fail;
39917 {
39918 PyThreadState* __tstate = wxPyBeginAllowThreads();
39919 result = (bool)(arg1)->IsSpacer();
39920
39921 wxPyEndAllowThreads(__tstate);
39922 if (PyErr_Occurred()) SWIG_fail;
39923 }
39924 {
39925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39926 }
39927 return resultobj;
39928 fail:
39929 return NULL;
39930 }
39931
39932
39933 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39934 PyObject *resultobj = NULL;
39935 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39936 int arg2 ;
39937 PyObject * obj0 = 0 ;
39938 PyObject * obj1 = 0 ;
39939 char *kwnames[] = {
39940 (char *) "self",(char *) "proportion", NULL
39941 };
39942
39943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39945 if (SWIG_arg_fail(1)) SWIG_fail;
39946 {
39947 arg2 = static_cast<int >(SWIG_As_int(obj1));
39948 if (SWIG_arg_fail(2)) SWIG_fail;
39949 }
39950 {
39951 PyThreadState* __tstate = wxPyBeginAllowThreads();
39952 (arg1)->SetProportion(arg2);
39953
39954 wxPyEndAllowThreads(__tstate);
39955 if (PyErr_Occurred()) SWIG_fail;
39956 }
39957 Py_INCREF(Py_None); resultobj = Py_None;
39958 return resultobj;
39959 fail:
39960 return NULL;
39961 }
39962
39963
39964 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39965 PyObject *resultobj = NULL;
39966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39967 int result;
39968 PyObject * obj0 = 0 ;
39969 char *kwnames[] = {
39970 (char *) "self", NULL
39971 };
39972
39973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39975 if (SWIG_arg_fail(1)) SWIG_fail;
39976 {
39977 PyThreadState* __tstate = wxPyBeginAllowThreads();
39978 result = (int)(arg1)->GetProportion();
39979
39980 wxPyEndAllowThreads(__tstate);
39981 if (PyErr_Occurred()) SWIG_fail;
39982 }
39983 {
39984 resultobj = SWIG_From_int(static_cast<int >(result));
39985 }
39986 return resultobj;
39987 fail:
39988 return NULL;
39989 }
39990
39991
39992 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39993 PyObject *resultobj = NULL;
39994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39995 int arg2 ;
39996 PyObject * obj0 = 0 ;
39997 PyObject * obj1 = 0 ;
39998 char *kwnames[] = {
39999 (char *) "self",(char *) "flag", NULL
40000 };
40001
40002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
40003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40004 if (SWIG_arg_fail(1)) SWIG_fail;
40005 {
40006 arg2 = static_cast<int >(SWIG_As_int(obj1));
40007 if (SWIG_arg_fail(2)) SWIG_fail;
40008 }
40009 {
40010 PyThreadState* __tstate = wxPyBeginAllowThreads();
40011 (arg1)->SetFlag(arg2);
40012
40013 wxPyEndAllowThreads(__tstate);
40014 if (PyErr_Occurred()) SWIG_fail;
40015 }
40016 Py_INCREF(Py_None); resultobj = Py_None;
40017 return resultobj;
40018 fail:
40019 return NULL;
40020 }
40021
40022
40023 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40024 PyObject *resultobj = NULL;
40025 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40026 int result;
40027 PyObject * obj0 = 0 ;
40028 char *kwnames[] = {
40029 (char *) "self", NULL
40030 };
40031
40032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40034 if (SWIG_arg_fail(1)) SWIG_fail;
40035 {
40036 PyThreadState* __tstate = wxPyBeginAllowThreads();
40037 result = (int)(arg1)->GetFlag();
40038
40039 wxPyEndAllowThreads(__tstate);
40040 if (PyErr_Occurred()) SWIG_fail;
40041 }
40042 {
40043 resultobj = SWIG_From_int(static_cast<int >(result));
40044 }
40045 return resultobj;
40046 fail:
40047 return NULL;
40048 }
40049
40050
40051 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40052 PyObject *resultobj = NULL;
40053 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40054 int arg2 ;
40055 PyObject * obj0 = 0 ;
40056 PyObject * obj1 = 0 ;
40057 char *kwnames[] = {
40058 (char *) "self",(char *) "border", NULL
40059 };
40060
40061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40063 if (SWIG_arg_fail(1)) SWIG_fail;
40064 {
40065 arg2 = static_cast<int >(SWIG_As_int(obj1));
40066 if (SWIG_arg_fail(2)) SWIG_fail;
40067 }
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 (arg1)->SetBorder(arg2);
40071
40072 wxPyEndAllowThreads(__tstate);
40073 if (PyErr_Occurred()) SWIG_fail;
40074 }
40075 Py_INCREF(Py_None); resultobj = Py_None;
40076 return resultobj;
40077 fail:
40078 return NULL;
40079 }
40080
40081
40082 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40083 PyObject *resultobj = NULL;
40084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40085 int result;
40086 PyObject * obj0 = 0 ;
40087 char *kwnames[] = {
40088 (char *) "self", NULL
40089 };
40090
40091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
40092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40093 if (SWIG_arg_fail(1)) SWIG_fail;
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 result = (int)(arg1)->GetBorder();
40097
40098 wxPyEndAllowThreads(__tstate);
40099 if (PyErr_Occurred()) SWIG_fail;
40100 }
40101 {
40102 resultobj = SWIG_From_int(static_cast<int >(result));
40103 }
40104 return resultobj;
40105 fail:
40106 return NULL;
40107 }
40108
40109
40110 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40111 PyObject *resultobj = NULL;
40112 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40113 wxWindow *result;
40114 PyObject * obj0 = 0 ;
40115 char *kwnames[] = {
40116 (char *) "self", NULL
40117 };
40118
40119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40121 if (SWIG_arg_fail(1)) SWIG_fail;
40122 {
40123 PyThreadState* __tstate = wxPyBeginAllowThreads();
40124 result = (wxWindow *)(arg1)->GetWindow();
40125
40126 wxPyEndAllowThreads(__tstate);
40127 if (PyErr_Occurred()) SWIG_fail;
40128 }
40129 {
40130 resultobj = wxPyMake_wxObject(result, 0);
40131 }
40132 return resultobj;
40133 fail:
40134 return NULL;
40135 }
40136
40137
40138 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40139 PyObject *resultobj = NULL;
40140 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40141 wxWindow *arg2 = (wxWindow *) 0 ;
40142 PyObject * obj0 = 0 ;
40143 PyObject * obj1 = 0 ;
40144 char *kwnames[] = {
40145 (char *) "self",(char *) "window", NULL
40146 };
40147
40148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
40149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40150 if (SWIG_arg_fail(1)) SWIG_fail;
40151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40152 if (SWIG_arg_fail(2)) SWIG_fail;
40153 {
40154 PyThreadState* __tstate = wxPyBeginAllowThreads();
40155 (arg1)->SetWindow(arg2);
40156
40157 wxPyEndAllowThreads(__tstate);
40158 if (PyErr_Occurred()) SWIG_fail;
40159 }
40160 Py_INCREF(Py_None); resultobj = Py_None;
40161 return resultobj;
40162 fail:
40163 return NULL;
40164 }
40165
40166
40167 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40168 PyObject *resultobj = NULL;
40169 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40170 wxSizer *result;
40171 PyObject * obj0 = 0 ;
40172 char *kwnames[] = {
40173 (char *) "self", NULL
40174 };
40175
40176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40178 if (SWIG_arg_fail(1)) SWIG_fail;
40179 {
40180 PyThreadState* __tstate = wxPyBeginAllowThreads();
40181 result = (wxSizer *)(arg1)->GetSizer();
40182
40183 wxPyEndAllowThreads(__tstate);
40184 if (PyErr_Occurred()) SWIG_fail;
40185 }
40186 {
40187 resultobj = wxPyMake_wxObject(result, (bool)0);
40188 }
40189 return resultobj;
40190 fail:
40191 return NULL;
40192 }
40193
40194
40195 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40196 PyObject *resultobj = NULL;
40197 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40198 wxSizer *arg2 = (wxSizer *) 0 ;
40199 PyObject * obj0 = 0 ;
40200 PyObject * obj1 = 0 ;
40201 char *kwnames[] = {
40202 (char *) "self",(char *) "sizer", NULL
40203 };
40204
40205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40207 if (SWIG_arg_fail(1)) SWIG_fail;
40208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40209 if (SWIG_arg_fail(2)) SWIG_fail;
40210 {
40211 PyThreadState* __tstate = wxPyBeginAllowThreads();
40212 (arg1)->SetSizer(arg2);
40213
40214 wxPyEndAllowThreads(__tstate);
40215 if (PyErr_Occurred()) SWIG_fail;
40216 }
40217 Py_INCREF(Py_None); resultobj = Py_None;
40218 return resultobj;
40219 fail:
40220 return NULL;
40221 }
40222
40223
40224 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40225 PyObject *resultobj = NULL;
40226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40227 wxSize *result;
40228 PyObject * obj0 = 0 ;
40229 char *kwnames[] = {
40230 (char *) "self", NULL
40231 };
40232
40233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40235 if (SWIG_arg_fail(1)) SWIG_fail;
40236 {
40237 PyThreadState* __tstate = wxPyBeginAllowThreads();
40238 {
40239 wxSize const &_result_ref = (arg1)->GetSpacer();
40240 result = (wxSize *) &_result_ref;
40241 }
40242
40243 wxPyEndAllowThreads(__tstate);
40244 if (PyErr_Occurred()) SWIG_fail;
40245 }
40246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40247 return resultobj;
40248 fail:
40249 return NULL;
40250 }
40251
40252
40253 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40254 PyObject *resultobj = NULL;
40255 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40256 wxSize *arg2 = 0 ;
40257 wxSize temp2 ;
40258 PyObject * obj0 = 0 ;
40259 PyObject * obj1 = 0 ;
40260 char *kwnames[] = {
40261 (char *) "self",(char *) "size", NULL
40262 };
40263
40264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40266 if (SWIG_arg_fail(1)) SWIG_fail;
40267 {
40268 arg2 = &temp2;
40269 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40270 }
40271 {
40272 PyThreadState* __tstate = wxPyBeginAllowThreads();
40273 (arg1)->SetSpacer((wxSize const &)*arg2);
40274
40275 wxPyEndAllowThreads(__tstate);
40276 if (PyErr_Occurred()) SWIG_fail;
40277 }
40278 Py_INCREF(Py_None); resultobj = Py_None;
40279 return resultobj;
40280 fail:
40281 return NULL;
40282 }
40283
40284
40285 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40286 PyObject *resultobj = NULL;
40287 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40288 bool arg2 ;
40289 PyObject * obj0 = 0 ;
40290 PyObject * obj1 = 0 ;
40291 char *kwnames[] = {
40292 (char *) "self",(char *) "show", NULL
40293 };
40294
40295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) 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 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40300 if (SWIG_arg_fail(2)) SWIG_fail;
40301 }
40302 {
40303 PyThreadState* __tstate = wxPyBeginAllowThreads();
40304 (arg1)->Show(arg2);
40305
40306 wxPyEndAllowThreads(__tstate);
40307 if (PyErr_Occurred()) SWIG_fail;
40308 }
40309 Py_INCREF(Py_None); resultobj = Py_None;
40310 return resultobj;
40311 fail:
40312 return NULL;
40313 }
40314
40315
40316 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40317 PyObject *resultobj = NULL;
40318 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40319 bool result;
40320 PyObject * obj0 = 0 ;
40321 char *kwnames[] = {
40322 (char *) "self", NULL
40323 };
40324
40325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40327 if (SWIG_arg_fail(1)) SWIG_fail;
40328 {
40329 PyThreadState* __tstate = wxPyBeginAllowThreads();
40330 result = (bool)(arg1)->IsShown();
40331
40332 wxPyEndAllowThreads(__tstate);
40333 if (PyErr_Occurred()) SWIG_fail;
40334 }
40335 {
40336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40337 }
40338 return resultobj;
40339 fail:
40340 return NULL;
40341 }
40342
40343
40344 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40345 PyObject *resultobj = NULL;
40346 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40347 wxPoint result;
40348 PyObject * obj0 = 0 ;
40349 char *kwnames[] = {
40350 (char *) "self", NULL
40351 };
40352
40353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40355 if (SWIG_arg_fail(1)) SWIG_fail;
40356 {
40357 PyThreadState* __tstate = wxPyBeginAllowThreads();
40358 result = (arg1)->GetPosition();
40359
40360 wxPyEndAllowThreads(__tstate);
40361 if (PyErr_Occurred()) SWIG_fail;
40362 }
40363 {
40364 wxPoint * resultptr;
40365 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40367 }
40368 return resultobj;
40369 fail:
40370 return NULL;
40371 }
40372
40373
40374 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj = NULL;
40376 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40377 PyObject *result;
40378 PyObject * obj0 = 0 ;
40379 char *kwnames[] = {
40380 (char *) "self", NULL
40381 };
40382
40383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40385 if (SWIG_arg_fail(1)) SWIG_fail;
40386 {
40387 PyThreadState* __tstate = wxPyBeginAllowThreads();
40388 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40389
40390 wxPyEndAllowThreads(__tstate);
40391 if (PyErr_Occurred()) SWIG_fail;
40392 }
40393 resultobj = result;
40394 return resultobj;
40395 fail:
40396 return NULL;
40397 }
40398
40399
40400 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40401 PyObject *resultobj = NULL;
40402 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40403 PyObject *arg2 = (PyObject *) 0 ;
40404 PyObject * obj0 = 0 ;
40405 PyObject * obj1 = 0 ;
40406 char *kwnames[] = {
40407 (char *) "self",(char *) "userData", NULL
40408 };
40409
40410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40412 if (SWIG_arg_fail(1)) SWIG_fail;
40413 arg2 = obj1;
40414 {
40415 PyThreadState* __tstate = wxPyBeginAllowThreads();
40416 wxSizerItem_SetUserData(arg1,arg2);
40417
40418 wxPyEndAllowThreads(__tstate);
40419 if (PyErr_Occurred()) SWIG_fail;
40420 }
40421 Py_INCREF(Py_None); resultobj = Py_None;
40422 return resultobj;
40423 fail:
40424 return NULL;
40425 }
40426
40427
40428 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40429 PyObject *obj;
40430 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40431 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40432 Py_INCREF(obj);
40433 return Py_BuildValue((char *)"");
40434 }
40435 static PyObject *_wrap_delete_Sizer(PyObject *, PyObject *args, PyObject *kwargs) {
40436 PyObject *resultobj = NULL;
40437 wxSizer *arg1 = (wxSizer *) 0 ;
40438 PyObject * obj0 = 0 ;
40439 char *kwnames[] = {
40440 (char *) "self", NULL
40441 };
40442
40443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sizer",kwnames,&obj0)) goto fail;
40444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40445 if (SWIG_arg_fail(1)) SWIG_fail;
40446 {
40447 PyThreadState* __tstate = wxPyBeginAllowThreads();
40448 delete arg1;
40449
40450 wxPyEndAllowThreads(__tstate);
40451 if (PyErr_Occurred()) SWIG_fail;
40452 }
40453 Py_INCREF(Py_None); resultobj = Py_None;
40454 return resultobj;
40455 fail:
40456 return NULL;
40457 }
40458
40459
40460 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40461 PyObject *resultobj = NULL;
40462 wxSizer *arg1 = (wxSizer *) 0 ;
40463 PyObject *arg2 = (PyObject *) 0 ;
40464 PyObject * obj0 = 0 ;
40465 PyObject * obj1 = 0 ;
40466 char *kwnames[] = {
40467 (char *) "self",(char *) "_self", NULL
40468 };
40469
40470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40472 if (SWIG_arg_fail(1)) SWIG_fail;
40473 arg2 = obj1;
40474 {
40475 PyThreadState* __tstate = wxPyBeginAllowThreads();
40476 wxSizer__setOORInfo(arg1,arg2);
40477
40478 wxPyEndAllowThreads(__tstate);
40479 if (PyErr_Occurred()) SWIG_fail;
40480 }
40481 Py_INCREF(Py_None); resultobj = Py_None;
40482 return resultobj;
40483 fail:
40484 return NULL;
40485 }
40486
40487
40488 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40489 PyObject *resultobj = NULL;
40490 wxSizer *arg1 = (wxSizer *) 0 ;
40491 PyObject *arg2 = (PyObject *) 0 ;
40492 int arg3 = (int) 0 ;
40493 int arg4 = (int) 0 ;
40494 int arg5 = (int) 0 ;
40495 PyObject *arg6 = (PyObject *) NULL ;
40496 wxSizerItem *result;
40497 PyObject * obj0 = 0 ;
40498 PyObject * obj1 = 0 ;
40499 PyObject * obj2 = 0 ;
40500 PyObject * obj3 = 0 ;
40501 PyObject * obj4 = 0 ;
40502 PyObject * obj5 = 0 ;
40503 char *kwnames[] = {
40504 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40505 };
40506
40507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40509 if (SWIG_arg_fail(1)) SWIG_fail;
40510 arg2 = obj1;
40511 if (obj2) {
40512 {
40513 arg3 = static_cast<int >(SWIG_As_int(obj2));
40514 if (SWIG_arg_fail(3)) SWIG_fail;
40515 }
40516 }
40517 if (obj3) {
40518 {
40519 arg4 = static_cast<int >(SWIG_As_int(obj3));
40520 if (SWIG_arg_fail(4)) SWIG_fail;
40521 }
40522 }
40523 if (obj4) {
40524 {
40525 arg5 = static_cast<int >(SWIG_As_int(obj4));
40526 if (SWIG_arg_fail(5)) SWIG_fail;
40527 }
40528 }
40529 if (obj5) {
40530 arg6 = obj5;
40531 }
40532 {
40533 PyThreadState* __tstate = wxPyBeginAllowThreads();
40534 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40535
40536 wxPyEndAllowThreads(__tstate);
40537 if (PyErr_Occurred()) SWIG_fail;
40538 }
40539 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40540 return resultobj;
40541 fail:
40542 return NULL;
40543 }
40544
40545
40546 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40547 PyObject *resultobj = NULL;
40548 wxSizer *arg1 = (wxSizer *) 0 ;
40549 int arg2 ;
40550 PyObject *arg3 = (PyObject *) 0 ;
40551 int arg4 = (int) 0 ;
40552 int arg5 = (int) 0 ;
40553 int arg6 = (int) 0 ;
40554 PyObject *arg7 = (PyObject *) NULL ;
40555 wxSizerItem *result;
40556 PyObject * obj0 = 0 ;
40557 PyObject * obj1 = 0 ;
40558 PyObject * obj2 = 0 ;
40559 PyObject * obj3 = 0 ;
40560 PyObject * obj4 = 0 ;
40561 PyObject * obj5 = 0 ;
40562 PyObject * obj6 = 0 ;
40563 char *kwnames[] = {
40564 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40565 };
40566
40567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40569 if (SWIG_arg_fail(1)) SWIG_fail;
40570 {
40571 arg2 = static_cast<int >(SWIG_As_int(obj1));
40572 if (SWIG_arg_fail(2)) SWIG_fail;
40573 }
40574 arg3 = obj2;
40575 if (obj3) {
40576 {
40577 arg4 = static_cast<int >(SWIG_As_int(obj3));
40578 if (SWIG_arg_fail(4)) SWIG_fail;
40579 }
40580 }
40581 if (obj4) {
40582 {
40583 arg5 = static_cast<int >(SWIG_As_int(obj4));
40584 if (SWIG_arg_fail(5)) SWIG_fail;
40585 }
40586 }
40587 if (obj5) {
40588 {
40589 arg6 = static_cast<int >(SWIG_As_int(obj5));
40590 if (SWIG_arg_fail(6)) SWIG_fail;
40591 }
40592 }
40593 if (obj6) {
40594 arg7 = obj6;
40595 }
40596 {
40597 PyThreadState* __tstate = wxPyBeginAllowThreads();
40598 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40599
40600 wxPyEndAllowThreads(__tstate);
40601 if (PyErr_Occurred()) SWIG_fail;
40602 }
40603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40604 return resultobj;
40605 fail:
40606 return NULL;
40607 }
40608
40609
40610 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40611 PyObject *resultobj = NULL;
40612 wxSizer *arg1 = (wxSizer *) 0 ;
40613 PyObject *arg2 = (PyObject *) 0 ;
40614 int arg3 = (int) 0 ;
40615 int arg4 = (int) 0 ;
40616 int arg5 = (int) 0 ;
40617 PyObject *arg6 = (PyObject *) NULL ;
40618 wxSizerItem *result;
40619 PyObject * obj0 = 0 ;
40620 PyObject * obj1 = 0 ;
40621 PyObject * obj2 = 0 ;
40622 PyObject * obj3 = 0 ;
40623 PyObject * obj4 = 0 ;
40624 PyObject * obj5 = 0 ;
40625 char *kwnames[] = {
40626 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40627 };
40628
40629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 arg2 = obj1;
40633 if (obj2) {
40634 {
40635 arg3 = static_cast<int >(SWIG_As_int(obj2));
40636 if (SWIG_arg_fail(3)) SWIG_fail;
40637 }
40638 }
40639 if (obj3) {
40640 {
40641 arg4 = static_cast<int >(SWIG_As_int(obj3));
40642 if (SWIG_arg_fail(4)) SWIG_fail;
40643 }
40644 }
40645 if (obj4) {
40646 {
40647 arg5 = static_cast<int >(SWIG_As_int(obj4));
40648 if (SWIG_arg_fail(5)) SWIG_fail;
40649 }
40650 }
40651 if (obj5) {
40652 arg6 = obj5;
40653 }
40654 {
40655 PyThreadState* __tstate = wxPyBeginAllowThreads();
40656 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40657
40658 wxPyEndAllowThreads(__tstate);
40659 if (PyErr_Occurred()) SWIG_fail;
40660 }
40661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40662 return resultobj;
40663 fail:
40664 return NULL;
40665 }
40666
40667
40668 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40669 PyObject *resultobj = NULL;
40670 wxSizer *arg1 = (wxSizer *) 0 ;
40671 PyObject *arg2 = (PyObject *) 0 ;
40672 bool result;
40673 PyObject * obj0 = 0 ;
40674 PyObject * obj1 = 0 ;
40675 char *kwnames[] = {
40676 (char *) "self",(char *) "item", NULL
40677 };
40678
40679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40681 if (SWIG_arg_fail(1)) SWIG_fail;
40682 arg2 = obj1;
40683 {
40684 PyThreadState* __tstate = wxPyBeginAllowThreads();
40685 result = (bool)wxSizer_Remove(arg1,arg2);
40686
40687 wxPyEndAllowThreads(__tstate);
40688 if (PyErr_Occurred()) SWIG_fail;
40689 }
40690 {
40691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40692 }
40693 return resultobj;
40694 fail:
40695 return NULL;
40696 }
40697
40698
40699 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40700 PyObject *resultobj = NULL;
40701 wxSizer *arg1 = (wxSizer *) 0 ;
40702 PyObject *arg2 = (PyObject *) 0 ;
40703 bool result;
40704 PyObject * obj0 = 0 ;
40705 PyObject * obj1 = 0 ;
40706 char *kwnames[] = {
40707 (char *) "self",(char *) "item", NULL
40708 };
40709
40710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40712 if (SWIG_arg_fail(1)) SWIG_fail;
40713 arg2 = obj1;
40714 {
40715 PyThreadState* __tstate = wxPyBeginAllowThreads();
40716 result = (bool)wxSizer_Detach(arg1,arg2);
40717
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 {
40722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40723 }
40724 return resultobj;
40725 fail:
40726 return NULL;
40727 }
40728
40729
40730 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40731 PyObject *resultobj = NULL;
40732 wxSizer *arg1 = (wxSizer *) 0 ;
40733 PyObject *arg2 = (PyObject *) 0 ;
40734 wxSizerItem *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_GetItem",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 = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40748
40749 wxPyEndAllowThreads(__tstate);
40750 if (PyErr_Occurred()) SWIG_fail;
40751 }
40752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40753 return resultobj;
40754 fail:
40755 return NULL;
40756 }
40757
40758
40759 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40760 PyObject *resultobj = NULL;
40761 wxSizer *arg1 = (wxSizer *) 0 ;
40762 PyObject *arg2 = (PyObject *) 0 ;
40763 wxSize *arg3 = 0 ;
40764 wxSize temp3 ;
40765 PyObject * obj0 = 0 ;
40766 PyObject * obj1 = 0 ;
40767 PyObject * obj2 = 0 ;
40768 char *kwnames[] = {
40769 (char *) "self",(char *) "item",(char *) "size", NULL
40770 };
40771
40772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) 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 arg3 = &temp3;
40778 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40779 }
40780 {
40781 PyThreadState* __tstate = wxPyBeginAllowThreads();
40782 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40783
40784 wxPyEndAllowThreads(__tstate);
40785 if (PyErr_Occurred()) SWIG_fail;
40786 }
40787 Py_INCREF(Py_None); resultobj = Py_None;
40788 return resultobj;
40789 fail:
40790 return NULL;
40791 }
40792
40793
40794 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40795 PyObject *resultobj = NULL;
40796 wxSizer *arg1 = (wxSizer *) 0 ;
40797 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40798 wxSizerItem *result;
40799 PyObject * obj0 = 0 ;
40800 PyObject * obj1 = 0 ;
40801 char *kwnames[] = {
40802 (char *) "self",(char *) "item", NULL
40803 };
40804
40805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40807 if (SWIG_arg_fail(1)) SWIG_fail;
40808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40809 if (SWIG_arg_fail(2)) SWIG_fail;
40810 {
40811 PyThreadState* __tstate = wxPyBeginAllowThreads();
40812 result = (wxSizerItem *)(arg1)->Add(arg2);
40813
40814 wxPyEndAllowThreads(__tstate);
40815 if (PyErr_Occurred()) SWIG_fail;
40816 }
40817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40818 return resultobj;
40819 fail:
40820 return NULL;
40821 }
40822
40823
40824 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40825 PyObject *resultobj = NULL;
40826 wxSizer *arg1 = (wxSizer *) 0 ;
40827 size_t arg2 ;
40828 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40829 wxSizerItem *result;
40830 PyObject * obj0 = 0 ;
40831 PyObject * obj1 = 0 ;
40832 PyObject * obj2 = 0 ;
40833 char *kwnames[] = {
40834 (char *) "self",(char *) "index",(char *) "item", NULL
40835 };
40836
40837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40839 if (SWIG_arg_fail(1)) SWIG_fail;
40840 {
40841 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40842 if (SWIG_arg_fail(2)) SWIG_fail;
40843 }
40844 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40845 if (SWIG_arg_fail(3)) SWIG_fail;
40846 {
40847 PyThreadState* __tstate = wxPyBeginAllowThreads();
40848 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40849
40850 wxPyEndAllowThreads(__tstate);
40851 if (PyErr_Occurred()) SWIG_fail;
40852 }
40853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40854 return resultobj;
40855 fail:
40856 return NULL;
40857 }
40858
40859
40860 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40861 PyObject *resultobj = NULL;
40862 wxSizer *arg1 = (wxSizer *) 0 ;
40863 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40864 wxSizerItem *result;
40865 PyObject * obj0 = 0 ;
40866 PyObject * obj1 = 0 ;
40867 char *kwnames[] = {
40868 (char *) "self",(char *) "item", NULL
40869 };
40870
40871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40873 if (SWIG_arg_fail(1)) SWIG_fail;
40874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40875 if (SWIG_arg_fail(2)) SWIG_fail;
40876 {
40877 PyThreadState* __tstate = wxPyBeginAllowThreads();
40878 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40879
40880 wxPyEndAllowThreads(__tstate);
40881 if (PyErr_Occurred()) SWIG_fail;
40882 }
40883 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40884 return resultobj;
40885 fail:
40886 return NULL;
40887 }
40888
40889
40890 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40891 PyObject *resultobj = NULL;
40892 wxSizer *arg1 = (wxSizer *) 0 ;
40893 int arg2 ;
40894 int arg3 ;
40895 int arg4 ;
40896 int arg5 ;
40897 PyObject * obj0 = 0 ;
40898 PyObject * obj1 = 0 ;
40899 PyObject * obj2 = 0 ;
40900 PyObject * obj3 = 0 ;
40901 PyObject * obj4 = 0 ;
40902 char *kwnames[] = {
40903 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40904 };
40905
40906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40908 if (SWIG_arg_fail(1)) SWIG_fail;
40909 {
40910 arg2 = static_cast<int >(SWIG_As_int(obj1));
40911 if (SWIG_arg_fail(2)) SWIG_fail;
40912 }
40913 {
40914 arg3 = static_cast<int >(SWIG_As_int(obj2));
40915 if (SWIG_arg_fail(3)) SWIG_fail;
40916 }
40917 {
40918 arg4 = static_cast<int >(SWIG_As_int(obj3));
40919 if (SWIG_arg_fail(4)) SWIG_fail;
40920 }
40921 {
40922 arg5 = static_cast<int >(SWIG_As_int(obj4));
40923 if (SWIG_arg_fail(5)) SWIG_fail;
40924 }
40925 {
40926 PyThreadState* __tstate = wxPyBeginAllowThreads();
40927 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40928
40929 wxPyEndAllowThreads(__tstate);
40930 if (PyErr_Occurred()) SWIG_fail;
40931 }
40932 Py_INCREF(Py_None); resultobj = Py_None;
40933 return resultobj;
40934 fail:
40935 return NULL;
40936 }
40937
40938
40939 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40940 PyObject *resultobj = NULL;
40941 wxSizer *arg1 = (wxSizer *) 0 ;
40942 wxSize *arg2 = 0 ;
40943 wxSize temp2 ;
40944 PyObject * obj0 = 0 ;
40945 PyObject * obj1 = 0 ;
40946 char *kwnames[] = {
40947 (char *) "self",(char *) "size", NULL
40948 };
40949
40950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40952 if (SWIG_arg_fail(1)) SWIG_fail;
40953 {
40954 arg2 = &temp2;
40955 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40956 }
40957 {
40958 PyThreadState* __tstate = wxPyBeginAllowThreads();
40959 (arg1)->SetMinSize((wxSize const &)*arg2);
40960
40961 wxPyEndAllowThreads(__tstate);
40962 if (PyErr_Occurred()) SWIG_fail;
40963 }
40964 Py_INCREF(Py_None); resultobj = Py_None;
40965 return resultobj;
40966 fail:
40967 return NULL;
40968 }
40969
40970
40971 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40972 PyObject *resultobj = NULL;
40973 wxSizer *arg1 = (wxSizer *) 0 ;
40974 wxSize result;
40975 PyObject * obj0 = 0 ;
40976 char *kwnames[] = {
40977 (char *) "self", NULL
40978 };
40979
40980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40982 if (SWIG_arg_fail(1)) SWIG_fail;
40983 {
40984 PyThreadState* __tstate = wxPyBeginAllowThreads();
40985 result = (arg1)->GetSize();
40986
40987 wxPyEndAllowThreads(__tstate);
40988 if (PyErr_Occurred()) SWIG_fail;
40989 }
40990 {
40991 wxSize * resultptr;
40992 resultptr = new wxSize(static_cast<wxSize & >(result));
40993 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40994 }
40995 return resultobj;
40996 fail:
40997 return NULL;
40998 }
40999
41000
41001 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41002 PyObject *resultobj = NULL;
41003 wxSizer *arg1 = (wxSizer *) 0 ;
41004 wxPoint result;
41005 PyObject * obj0 = 0 ;
41006 char *kwnames[] = {
41007 (char *) "self", NULL
41008 };
41009
41010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
41011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41012 if (SWIG_arg_fail(1)) SWIG_fail;
41013 {
41014 PyThreadState* __tstate = wxPyBeginAllowThreads();
41015 result = (arg1)->GetPosition();
41016
41017 wxPyEndAllowThreads(__tstate);
41018 if (PyErr_Occurred()) SWIG_fail;
41019 }
41020 {
41021 wxPoint * resultptr;
41022 resultptr = new wxPoint(static_cast<wxPoint & >(result));
41023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
41024 }
41025 return resultobj;
41026 fail:
41027 return NULL;
41028 }
41029
41030
41031 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41032 PyObject *resultobj = NULL;
41033 wxSizer *arg1 = (wxSizer *) 0 ;
41034 wxSize result;
41035 PyObject * obj0 = 0 ;
41036 char *kwnames[] = {
41037 (char *) "self", NULL
41038 };
41039
41040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
41041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41042 if (SWIG_arg_fail(1)) SWIG_fail;
41043 {
41044 PyThreadState* __tstate = wxPyBeginAllowThreads();
41045 result = (arg1)->GetMinSize();
41046
41047 wxPyEndAllowThreads(__tstate);
41048 if (PyErr_Occurred()) SWIG_fail;
41049 }
41050 {
41051 wxSize * resultptr;
41052 resultptr = new wxSize(static_cast<wxSize & >(result));
41053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41054 }
41055 return resultobj;
41056 fail:
41057 return NULL;
41058 }
41059
41060
41061 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41062 PyObject *resultobj = NULL;
41063 wxSizer *arg1 = (wxSizer *) 0 ;
41064 PyObject * obj0 = 0 ;
41065 char *kwnames[] = {
41066 (char *) "self", NULL
41067 };
41068
41069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41071 if (SWIG_arg_fail(1)) SWIG_fail;
41072 {
41073 PyThreadState* __tstate = wxPyBeginAllowThreads();
41074 (arg1)->RecalcSizes();
41075
41076 wxPyEndAllowThreads(__tstate);
41077 if (PyErr_Occurred()) SWIG_fail;
41078 }
41079 Py_INCREF(Py_None); resultobj = Py_None;
41080 return resultobj;
41081 fail:
41082 return NULL;
41083 }
41084
41085
41086 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41087 PyObject *resultobj = NULL;
41088 wxSizer *arg1 = (wxSizer *) 0 ;
41089 wxSize result;
41090 PyObject * obj0 = 0 ;
41091 char *kwnames[] = {
41092 (char *) "self", NULL
41093 };
41094
41095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41097 if (SWIG_arg_fail(1)) SWIG_fail;
41098 {
41099 PyThreadState* __tstate = wxPyBeginAllowThreads();
41100 result = (arg1)->CalcMin();
41101
41102 wxPyEndAllowThreads(__tstate);
41103 if (PyErr_Occurred()) SWIG_fail;
41104 }
41105 {
41106 wxSize * resultptr;
41107 resultptr = new wxSize(static_cast<wxSize & >(result));
41108 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41109 }
41110 return resultobj;
41111 fail:
41112 return NULL;
41113 }
41114
41115
41116 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41117 PyObject *resultobj = NULL;
41118 wxSizer *arg1 = (wxSizer *) 0 ;
41119 PyObject * obj0 = 0 ;
41120 char *kwnames[] = {
41121 (char *) "self", NULL
41122 };
41123
41124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41126 if (SWIG_arg_fail(1)) SWIG_fail;
41127 {
41128 PyThreadState* __tstate = wxPyBeginAllowThreads();
41129 (arg1)->Layout();
41130
41131 wxPyEndAllowThreads(__tstate);
41132 if (PyErr_Occurred()) SWIG_fail;
41133 }
41134 Py_INCREF(Py_None); resultobj = Py_None;
41135 return resultobj;
41136 fail:
41137 return NULL;
41138 }
41139
41140
41141 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41142 PyObject *resultobj = NULL;
41143 wxSizer *arg1 = (wxSizer *) 0 ;
41144 wxWindow *arg2 = (wxWindow *) 0 ;
41145 wxSize result;
41146 PyObject * obj0 = 0 ;
41147 PyObject * obj1 = 0 ;
41148 char *kwnames[] = {
41149 (char *) "self",(char *) "window", NULL
41150 };
41151
41152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41154 if (SWIG_arg_fail(1)) SWIG_fail;
41155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41156 if (SWIG_arg_fail(2)) SWIG_fail;
41157 {
41158 PyThreadState* __tstate = wxPyBeginAllowThreads();
41159 result = (arg1)->Fit(arg2);
41160
41161 wxPyEndAllowThreads(__tstate);
41162 if (PyErr_Occurred()) SWIG_fail;
41163 }
41164 {
41165 wxSize * resultptr;
41166 resultptr = new wxSize(static_cast<wxSize & >(result));
41167 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41168 }
41169 return resultobj;
41170 fail:
41171 return NULL;
41172 }
41173
41174
41175 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41176 PyObject *resultobj = NULL;
41177 wxSizer *arg1 = (wxSizer *) 0 ;
41178 wxWindow *arg2 = (wxWindow *) 0 ;
41179 PyObject * obj0 = 0 ;
41180 PyObject * obj1 = 0 ;
41181 char *kwnames[] = {
41182 (char *) "self",(char *) "window", NULL
41183 };
41184
41185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
41186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41187 if (SWIG_arg_fail(1)) SWIG_fail;
41188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41189 if (SWIG_arg_fail(2)) SWIG_fail;
41190 {
41191 PyThreadState* __tstate = wxPyBeginAllowThreads();
41192 (arg1)->FitInside(arg2);
41193
41194 wxPyEndAllowThreads(__tstate);
41195 if (PyErr_Occurred()) SWIG_fail;
41196 }
41197 Py_INCREF(Py_None); resultobj = Py_None;
41198 return resultobj;
41199 fail:
41200 return NULL;
41201 }
41202
41203
41204 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41205 PyObject *resultobj = NULL;
41206 wxSizer *arg1 = (wxSizer *) 0 ;
41207 wxWindow *arg2 = (wxWindow *) 0 ;
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_SetSizeHints",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 (arg1)->SetSizeHints(arg2);
41222
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 Py_INCREF(Py_None); resultobj = Py_None;
41227 return resultobj;
41228 fail:
41229 return NULL;
41230 }
41231
41232
41233 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41234 PyObject *resultobj = NULL;
41235 wxSizer *arg1 = (wxSizer *) 0 ;
41236 wxWindow *arg2 = (wxWindow *) 0 ;
41237 PyObject * obj0 = 0 ;
41238 PyObject * obj1 = 0 ;
41239 char *kwnames[] = {
41240 (char *) "self",(char *) "window", NULL
41241 };
41242
41243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41245 if (SWIG_arg_fail(1)) SWIG_fail;
41246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41247 if (SWIG_arg_fail(2)) SWIG_fail;
41248 {
41249 PyThreadState* __tstate = wxPyBeginAllowThreads();
41250 (arg1)->SetVirtualSizeHints(arg2);
41251
41252 wxPyEndAllowThreads(__tstate);
41253 if (PyErr_Occurred()) SWIG_fail;
41254 }
41255 Py_INCREF(Py_None); resultobj = Py_None;
41256 return resultobj;
41257 fail:
41258 return NULL;
41259 }
41260
41261
41262 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41263 PyObject *resultobj = NULL;
41264 wxSizer *arg1 = (wxSizer *) 0 ;
41265 bool arg2 = (bool) false ;
41266 PyObject * obj0 = 0 ;
41267 PyObject * obj1 = 0 ;
41268 char *kwnames[] = {
41269 (char *) "self",(char *) "deleteWindows", NULL
41270 };
41271
41272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41274 if (SWIG_arg_fail(1)) SWIG_fail;
41275 if (obj1) {
41276 {
41277 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41278 if (SWIG_arg_fail(2)) SWIG_fail;
41279 }
41280 }
41281 {
41282 PyThreadState* __tstate = wxPyBeginAllowThreads();
41283 (arg1)->Clear(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_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41296 PyObject *resultobj = NULL;
41297 wxSizer *arg1 = (wxSizer *) 0 ;
41298 PyObject * obj0 = 0 ;
41299 char *kwnames[] = {
41300 (char *) "self", NULL
41301 };
41302
41303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41305 if (SWIG_arg_fail(1)) SWIG_fail;
41306 {
41307 PyThreadState* __tstate = wxPyBeginAllowThreads();
41308 (arg1)->DeleteWindows();
41309
41310 wxPyEndAllowThreads(__tstate);
41311 if (PyErr_Occurred()) SWIG_fail;
41312 }
41313 Py_INCREF(Py_None); resultobj = Py_None;
41314 return resultobj;
41315 fail:
41316 return NULL;
41317 }
41318
41319
41320 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41321 PyObject *resultobj = NULL;
41322 wxSizer *arg1 = (wxSizer *) 0 ;
41323 PyObject *result;
41324 PyObject * obj0 = 0 ;
41325 char *kwnames[] = {
41326 (char *) "self", NULL
41327 };
41328
41329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41331 if (SWIG_arg_fail(1)) SWIG_fail;
41332 {
41333 PyThreadState* __tstate = wxPyBeginAllowThreads();
41334 result = (PyObject *)wxSizer_GetChildren(arg1);
41335
41336 wxPyEndAllowThreads(__tstate);
41337 if (PyErr_Occurred()) SWIG_fail;
41338 }
41339 resultobj = result;
41340 return resultobj;
41341 fail:
41342 return NULL;
41343 }
41344
41345
41346 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41347 PyObject *resultobj = NULL;
41348 wxSizer *arg1 = (wxSizer *) 0 ;
41349 PyObject *arg2 = (PyObject *) 0 ;
41350 bool arg3 = (bool) true ;
41351 bool arg4 = (bool) false ;
41352 bool result;
41353 PyObject * obj0 = 0 ;
41354 PyObject * obj1 = 0 ;
41355 PyObject * obj2 = 0 ;
41356 PyObject * obj3 = 0 ;
41357 char *kwnames[] = {
41358 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41359 };
41360
41361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41363 if (SWIG_arg_fail(1)) SWIG_fail;
41364 arg2 = obj1;
41365 if (obj2) {
41366 {
41367 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41368 if (SWIG_arg_fail(3)) SWIG_fail;
41369 }
41370 }
41371 if (obj3) {
41372 {
41373 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41374 if (SWIG_arg_fail(4)) SWIG_fail;
41375 }
41376 }
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41380
41381 wxPyEndAllowThreads(__tstate);
41382 if (PyErr_Occurred()) SWIG_fail;
41383 }
41384 {
41385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41386 }
41387 return resultobj;
41388 fail:
41389 return NULL;
41390 }
41391
41392
41393 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41394 PyObject *resultobj = NULL;
41395 wxSizer *arg1 = (wxSizer *) 0 ;
41396 PyObject *arg2 = (PyObject *) 0 ;
41397 bool result;
41398 PyObject * obj0 = 0 ;
41399 PyObject * obj1 = 0 ;
41400 char *kwnames[] = {
41401 (char *) "self",(char *) "item", NULL
41402 };
41403
41404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41406 if (SWIG_arg_fail(1)) SWIG_fail;
41407 arg2 = obj1;
41408 {
41409 PyThreadState* __tstate = wxPyBeginAllowThreads();
41410 result = (bool)wxSizer_IsShown(arg1,arg2);
41411
41412 wxPyEndAllowThreads(__tstate);
41413 if (PyErr_Occurred()) SWIG_fail;
41414 }
41415 {
41416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41417 }
41418 return resultobj;
41419 fail:
41420 return NULL;
41421 }
41422
41423
41424 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41425 PyObject *resultobj = NULL;
41426 wxSizer *arg1 = (wxSizer *) 0 ;
41427 bool arg2 ;
41428 PyObject * obj0 = 0 ;
41429 PyObject * obj1 = 0 ;
41430 char *kwnames[] = {
41431 (char *) "self",(char *) "show", NULL
41432 };
41433
41434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41436 if (SWIG_arg_fail(1)) SWIG_fail;
41437 {
41438 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41439 if (SWIG_arg_fail(2)) SWIG_fail;
41440 }
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 (arg1)->ShowItems(arg2);
41444
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 Py_INCREF(Py_None); resultobj = Py_None;
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41456 PyObject *obj;
41457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41458 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41459 Py_INCREF(obj);
41460 return Py_BuildValue((char *)"");
41461 }
41462 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41463 PyObject *resultobj = NULL;
41464 wxPySizer *result;
41465 char *kwnames[] = {
41466 NULL
41467 };
41468
41469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41470 {
41471 PyThreadState* __tstate = wxPyBeginAllowThreads();
41472 result = (wxPySizer *)new wxPySizer();
41473
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41478 return resultobj;
41479 fail:
41480 return NULL;
41481 }
41482
41483
41484 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41485 PyObject *resultobj = NULL;
41486 wxPySizer *arg1 = (wxPySizer *) 0 ;
41487 PyObject *arg2 = (PyObject *) 0 ;
41488 PyObject *arg3 = (PyObject *) 0 ;
41489 PyObject * obj0 = 0 ;
41490 PyObject * obj1 = 0 ;
41491 PyObject * obj2 = 0 ;
41492 char *kwnames[] = {
41493 (char *) "self",(char *) "self",(char *) "_class", NULL
41494 };
41495
41496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41498 if (SWIG_arg_fail(1)) SWIG_fail;
41499 arg2 = obj1;
41500 arg3 = obj2;
41501 {
41502 PyThreadState* __tstate = wxPyBeginAllowThreads();
41503 (arg1)->_setCallbackInfo(arg2,arg3);
41504
41505 wxPyEndAllowThreads(__tstate);
41506 if (PyErr_Occurred()) SWIG_fail;
41507 }
41508 Py_INCREF(Py_None); resultobj = Py_None;
41509 return resultobj;
41510 fail:
41511 return NULL;
41512 }
41513
41514
41515 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41516 PyObject *obj;
41517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41518 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41519 Py_INCREF(obj);
41520 return Py_BuildValue((char *)"");
41521 }
41522 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41523 PyObject *resultobj = NULL;
41524 int arg1 = (int) wxHORIZONTAL ;
41525 wxBoxSizer *result;
41526 PyObject * obj0 = 0 ;
41527 char *kwnames[] = {
41528 (char *) "orient", NULL
41529 };
41530
41531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41532 if (obj0) {
41533 {
41534 arg1 = static_cast<int >(SWIG_As_int(obj0));
41535 if (SWIG_arg_fail(1)) SWIG_fail;
41536 }
41537 }
41538 {
41539 PyThreadState* __tstate = wxPyBeginAllowThreads();
41540 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41541
41542 wxPyEndAllowThreads(__tstate);
41543 if (PyErr_Occurred()) SWIG_fail;
41544 }
41545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41546 return resultobj;
41547 fail:
41548 return NULL;
41549 }
41550
41551
41552 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41553 PyObject *resultobj = NULL;
41554 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41555 int result;
41556 PyObject * obj0 = 0 ;
41557 char *kwnames[] = {
41558 (char *) "self", NULL
41559 };
41560
41561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41563 if (SWIG_arg_fail(1)) SWIG_fail;
41564 {
41565 PyThreadState* __tstate = wxPyBeginAllowThreads();
41566 result = (int)(arg1)->GetOrientation();
41567
41568 wxPyEndAllowThreads(__tstate);
41569 if (PyErr_Occurred()) SWIG_fail;
41570 }
41571 {
41572 resultobj = SWIG_From_int(static_cast<int >(result));
41573 }
41574 return resultobj;
41575 fail:
41576 return NULL;
41577 }
41578
41579
41580 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41581 PyObject *resultobj = NULL;
41582 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41583 int arg2 ;
41584 PyObject * obj0 = 0 ;
41585 PyObject * obj1 = 0 ;
41586 char *kwnames[] = {
41587 (char *) "self",(char *) "orient", NULL
41588 };
41589
41590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41592 if (SWIG_arg_fail(1)) SWIG_fail;
41593 {
41594 arg2 = static_cast<int >(SWIG_As_int(obj1));
41595 if (SWIG_arg_fail(2)) SWIG_fail;
41596 }
41597 {
41598 PyThreadState* __tstate = wxPyBeginAllowThreads();
41599 (arg1)->SetOrientation(arg2);
41600
41601 wxPyEndAllowThreads(__tstate);
41602 if (PyErr_Occurred()) SWIG_fail;
41603 }
41604 Py_INCREF(Py_None); resultobj = Py_None;
41605 return resultobj;
41606 fail:
41607 return NULL;
41608 }
41609
41610
41611 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41612 PyObject *obj;
41613 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41614 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41615 Py_INCREF(obj);
41616 return Py_BuildValue((char *)"");
41617 }
41618 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41619 PyObject *resultobj = NULL;
41620 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41621 int arg2 = (int) wxHORIZONTAL ;
41622 wxStaticBoxSizer *result;
41623 PyObject * obj0 = 0 ;
41624 PyObject * obj1 = 0 ;
41625 char *kwnames[] = {
41626 (char *) "box",(char *) "orient", NULL
41627 };
41628
41629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41631 if (SWIG_arg_fail(1)) SWIG_fail;
41632 if (obj1) {
41633 {
41634 arg2 = static_cast<int >(SWIG_As_int(obj1));
41635 if (SWIG_arg_fail(2)) SWIG_fail;
41636 }
41637 }
41638 {
41639 PyThreadState* __tstate = wxPyBeginAllowThreads();
41640 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41641
41642 wxPyEndAllowThreads(__tstate);
41643 if (PyErr_Occurred()) SWIG_fail;
41644 }
41645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41646 return resultobj;
41647 fail:
41648 return NULL;
41649 }
41650
41651
41652 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41653 PyObject *resultobj = NULL;
41654 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41655 wxStaticBox *result;
41656 PyObject * obj0 = 0 ;
41657 char *kwnames[] = {
41658 (char *) "self", NULL
41659 };
41660
41661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41663 if (SWIG_arg_fail(1)) SWIG_fail;
41664 {
41665 PyThreadState* __tstate = wxPyBeginAllowThreads();
41666 result = (wxStaticBox *)(arg1)->GetStaticBox();
41667
41668 wxPyEndAllowThreads(__tstate);
41669 if (PyErr_Occurred()) SWIG_fail;
41670 }
41671 {
41672 resultobj = wxPyMake_wxObject(result, (bool)0);
41673 }
41674 return resultobj;
41675 fail:
41676 return NULL;
41677 }
41678
41679
41680 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41681 PyObject *obj;
41682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41683 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41684 Py_INCREF(obj);
41685 return Py_BuildValue((char *)"");
41686 }
41687 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41688 PyObject *resultobj = NULL;
41689 int arg1 = (int) 1 ;
41690 int arg2 = (int) 0 ;
41691 int arg3 = (int) 0 ;
41692 int arg4 = (int) 0 ;
41693 wxGridSizer *result;
41694 PyObject * obj0 = 0 ;
41695 PyObject * obj1 = 0 ;
41696 PyObject * obj2 = 0 ;
41697 PyObject * obj3 = 0 ;
41698 char *kwnames[] = {
41699 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41700 };
41701
41702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41703 if (obj0) {
41704 {
41705 arg1 = static_cast<int >(SWIG_As_int(obj0));
41706 if (SWIG_arg_fail(1)) SWIG_fail;
41707 }
41708 }
41709 if (obj1) {
41710 {
41711 arg2 = static_cast<int >(SWIG_As_int(obj1));
41712 if (SWIG_arg_fail(2)) SWIG_fail;
41713 }
41714 }
41715 if (obj2) {
41716 {
41717 arg3 = static_cast<int >(SWIG_As_int(obj2));
41718 if (SWIG_arg_fail(3)) SWIG_fail;
41719 }
41720 }
41721 if (obj3) {
41722 {
41723 arg4 = static_cast<int >(SWIG_As_int(obj3));
41724 if (SWIG_arg_fail(4)) SWIG_fail;
41725 }
41726 }
41727 {
41728 PyThreadState* __tstate = wxPyBeginAllowThreads();
41729 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41730
41731 wxPyEndAllowThreads(__tstate);
41732 if (PyErr_Occurred()) SWIG_fail;
41733 }
41734 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41735 return resultobj;
41736 fail:
41737 return NULL;
41738 }
41739
41740
41741 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj = NULL;
41743 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41744 int arg2 ;
41745 PyObject * obj0 = 0 ;
41746 PyObject * obj1 = 0 ;
41747 char *kwnames[] = {
41748 (char *) "self",(char *) "cols", NULL
41749 };
41750
41751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41753 if (SWIG_arg_fail(1)) SWIG_fail;
41754 {
41755 arg2 = static_cast<int >(SWIG_As_int(obj1));
41756 if (SWIG_arg_fail(2)) SWIG_fail;
41757 }
41758 {
41759 PyThreadState* __tstate = wxPyBeginAllowThreads();
41760 (arg1)->SetCols(arg2);
41761
41762 wxPyEndAllowThreads(__tstate);
41763 if (PyErr_Occurred()) SWIG_fail;
41764 }
41765 Py_INCREF(Py_None); resultobj = Py_None;
41766 return resultobj;
41767 fail:
41768 return NULL;
41769 }
41770
41771
41772 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41773 PyObject *resultobj = NULL;
41774 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41775 int arg2 ;
41776 PyObject * obj0 = 0 ;
41777 PyObject * obj1 = 0 ;
41778 char *kwnames[] = {
41779 (char *) "self",(char *) "rows", NULL
41780 };
41781
41782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41784 if (SWIG_arg_fail(1)) SWIG_fail;
41785 {
41786 arg2 = static_cast<int >(SWIG_As_int(obj1));
41787 if (SWIG_arg_fail(2)) SWIG_fail;
41788 }
41789 {
41790 PyThreadState* __tstate = wxPyBeginAllowThreads();
41791 (arg1)->SetRows(arg2);
41792
41793 wxPyEndAllowThreads(__tstate);
41794 if (PyErr_Occurred()) SWIG_fail;
41795 }
41796 Py_INCREF(Py_None); resultobj = Py_None;
41797 return resultobj;
41798 fail:
41799 return NULL;
41800 }
41801
41802
41803 static PyObject *_wrap_GridSizer_SetVGap(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 *) "gap", NULL
41811 };
41812
41813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",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)->SetVGap(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_SetHGap(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 *) "gap", NULL
41842 };
41843
41844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",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)->SetHGap(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_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41866 PyObject *resultobj = NULL;
41867 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41868 int result;
41869 PyObject * obj0 = 0 ;
41870 char *kwnames[] = {
41871 (char *) "self", NULL
41872 };
41873
41874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41876 if (SWIG_arg_fail(1)) SWIG_fail;
41877 {
41878 PyThreadState* __tstate = wxPyBeginAllowThreads();
41879 result = (int)(arg1)->GetCols();
41880
41881 wxPyEndAllowThreads(__tstate);
41882 if (PyErr_Occurred()) SWIG_fail;
41883 }
41884 {
41885 resultobj = SWIG_From_int(static_cast<int >(result));
41886 }
41887 return resultobj;
41888 fail:
41889 return NULL;
41890 }
41891
41892
41893 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41894 PyObject *resultobj = NULL;
41895 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41896 int result;
41897 PyObject * obj0 = 0 ;
41898 char *kwnames[] = {
41899 (char *) "self", NULL
41900 };
41901
41902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41904 if (SWIG_arg_fail(1)) SWIG_fail;
41905 {
41906 PyThreadState* __tstate = wxPyBeginAllowThreads();
41907 result = (int)(arg1)->GetRows();
41908
41909 wxPyEndAllowThreads(__tstate);
41910 if (PyErr_Occurred()) SWIG_fail;
41911 }
41912 {
41913 resultobj = SWIG_From_int(static_cast<int >(result));
41914 }
41915 return resultobj;
41916 fail:
41917 return NULL;
41918 }
41919
41920
41921 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41922 PyObject *resultobj = NULL;
41923 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41924 int result;
41925 PyObject * obj0 = 0 ;
41926 char *kwnames[] = {
41927 (char *) "self", NULL
41928 };
41929
41930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41932 if (SWIG_arg_fail(1)) SWIG_fail;
41933 {
41934 PyThreadState* __tstate = wxPyBeginAllowThreads();
41935 result = (int)(arg1)->GetVGap();
41936
41937 wxPyEndAllowThreads(__tstate);
41938 if (PyErr_Occurred()) SWIG_fail;
41939 }
41940 {
41941 resultobj = SWIG_From_int(static_cast<int >(result));
41942 }
41943 return resultobj;
41944 fail:
41945 return NULL;
41946 }
41947
41948
41949 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41950 PyObject *resultobj = NULL;
41951 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41952 int result;
41953 PyObject * obj0 = 0 ;
41954 char *kwnames[] = {
41955 (char *) "self", NULL
41956 };
41957
41958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41960 if (SWIG_arg_fail(1)) SWIG_fail;
41961 {
41962 PyThreadState* __tstate = wxPyBeginAllowThreads();
41963 result = (int)(arg1)->GetHGap();
41964
41965 wxPyEndAllowThreads(__tstate);
41966 if (PyErr_Occurred()) SWIG_fail;
41967 }
41968 {
41969 resultobj = SWIG_From_int(static_cast<int >(result));
41970 }
41971 return resultobj;
41972 fail:
41973 return NULL;
41974 }
41975
41976
41977 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41978 PyObject *obj;
41979 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41980 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41981 Py_INCREF(obj);
41982 return Py_BuildValue((char *)"");
41983 }
41984 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41985 PyObject *resultobj = NULL;
41986 int arg1 = (int) 1 ;
41987 int arg2 = (int) 0 ;
41988 int arg3 = (int) 0 ;
41989 int arg4 = (int) 0 ;
41990 wxFlexGridSizer *result;
41991 PyObject * obj0 = 0 ;
41992 PyObject * obj1 = 0 ;
41993 PyObject * obj2 = 0 ;
41994 PyObject * obj3 = 0 ;
41995 char *kwnames[] = {
41996 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41997 };
41998
41999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42000 if (obj0) {
42001 {
42002 arg1 = static_cast<int >(SWIG_As_int(obj0));
42003 if (SWIG_arg_fail(1)) SWIG_fail;
42004 }
42005 }
42006 if (obj1) {
42007 {
42008 arg2 = static_cast<int >(SWIG_As_int(obj1));
42009 if (SWIG_arg_fail(2)) SWIG_fail;
42010 }
42011 }
42012 if (obj2) {
42013 {
42014 arg3 = static_cast<int >(SWIG_As_int(obj2));
42015 if (SWIG_arg_fail(3)) SWIG_fail;
42016 }
42017 }
42018 if (obj3) {
42019 {
42020 arg4 = static_cast<int >(SWIG_As_int(obj3));
42021 if (SWIG_arg_fail(4)) SWIG_fail;
42022 }
42023 }
42024 {
42025 PyThreadState* __tstate = wxPyBeginAllowThreads();
42026 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
42027
42028 wxPyEndAllowThreads(__tstate);
42029 if (PyErr_Occurred()) SWIG_fail;
42030 }
42031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
42032 return resultobj;
42033 fail:
42034 return NULL;
42035 }
42036
42037
42038 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42039 PyObject *resultobj = NULL;
42040 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42041 size_t arg2 ;
42042 int arg3 = (int) 0 ;
42043 PyObject * obj0 = 0 ;
42044 PyObject * obj1 = 0 ;
42045 PyObject * obj2 = 0 ;
42046 char *kwnames[] = {
42047 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42048 };
42049
42050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42052 if (SWIG_arg_fail(1)) SWIG_fail;
42053 {
42054 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42055 if (SWIG_arg_fail(2)) SWIG_fail;
42056 }
42057 if (obj2) {
42058 {
42059 arg3 = static_cast<int >(SWIG_As_int(obj2));
42060 if (SWIG_arg_fail(3)) SWIG_fail;
42061 }
42062 }
42063 {
42064 PyThreadState* __tstate = wxPyBeginAllowThreads();
42065 (arg1)->AddGrowableRow(arg2,arg3);
42066
42067 wxPyEndAllowThreads(__tstate);
42068 if (PyErr_Occurred()) SWIG_fail;
42069 }
42070 Py_INCREF(Py_None); resultobj = Py_None;
42071 return resultobj;
42072 fail:
42073 return NULL;
42074 }
42075
42076
42077 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42078 PyObject *resultobj = NULL;
42079 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42080 size_t arg2 ;
42081 PyObject * obj0 = 0 ;
42082 PyObject * obj1 = 0 ;
42083 char *kwnames[] = {
42084 (char *) "self",(char *) "idx", NULL
42085 };
42086
42087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42089 if (SWIG_arg_fail(1)) SWIG_fail;
42090 {
42091 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42092 if (SWIG_arg_fail(2)) SWIG_fail;
42093 }
42094 {
42095 PyThreadState* __tstate = wxPyBeginAllowThreads();
42096 (arg1)->RemoveGrowableRow(arg2);
42097
42098 wxPyEndAllowThreads(__tstate);
42099 if (PyErr_Occurred()) SWIG_fail;
42100 }
42101 Py_INCREF(Py_None); resultobj = Py_None;
42102 return resultobj;
42103 fail:
42104 return NULL;
42105 }
42106
42107
42108 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42109 PyObject *resultobj = NULL;
42110 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42111 size_t arg2 ;
42112 int arg3 = (int) 0 ;
42113 PyObject * obj0 = 0 ;
42114 PyObject * obj1 = 0 ;
42115 PyObject * obj2 = 0 ;
42116 char *kwnames[] = {
42117 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42118 };
42119
42120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42122 if (SWIG_arg_fail(1)) SWIG_fail;
42123 {
42124 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42125 if (SWIG_arg_fail(2)) SWIG_fail;
42126 }
42127 if (obj2) {
42128 {
42129 arg3 = static_cast<int >(SWIG_As_int(obj2));
42130 if (SWIG_arg_fail(3)) SWIG_fail;
42131 }
42132 }
42133 {
42134 PyThreadState* __tstate = wxPyBeginAllowThreads();
42135 (arg1)->AddGrowableCol(arg2,arg3);
42136
42137 wxPyEndAllowThreads(__tstate);
42138 if (PyErr_Occurred()) SWIG_fail;
42139 }
42140 Py_INCREF(Py_None); resultobj = Py_None;
42141 return resultobj;
42142 fail:
42143 return NULL;
42144 }
42145
42146
42147 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42148 PyObject *resultobj = NULL;
42149 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42150 size_t arg2 ;
42151 PyObject * obj0 = 0 ;
42152 PyObject * obj1 = 0 ;
42153 char *kwnames[] = {
42154 (char *) "self",(char *) "idx", NULL
42155 };
42156
42157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42159 if (SWIG_arg_fail(1)) SWIG_fail;
42160 {
42161 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42162 if (SWIG_arg_fail(2)) SWIG_fail;
42163 }
42164 {
42165 PyThreadState* __tstate = wxPyBeginAllowThreads();
42166 (arg1)->RemoveGrowableCol(arg2);
42167
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 Py_INCREF(Py_None); resultobj = Py_None;
42172 return resultobj;
42173 fail:
42174 return NULL;
42175 }
42176
42177
42178 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42179 PyObject *resultobj = NULL;
42180 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42181 int arg2 ;
42182 PyObject * obj0 = 0 ;
42183 PyObject * obj1 = 0 ;
42184 char *kwnames[] = {
42185 (char *) "self",(char *) "direction", NULL
42186 };
42187
42188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42190 if (SWIG_arg_fail(1)) SWIG_fail;
42191 {
42192 arg2 = static_cast<int >(SWIG_As_int(obj1));
42193 if (SWIG_arg_fail(2)) SWIG_fail;
42194 }
42195 {
42196 PyThreadState* __tstate = wxPyBeginAllowThreads();
42197 (arg1)->SetFlexibleDirection(arg2);
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_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42210 PyObject *resultobj = NULL;
42211 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42212 int result;
42213 PyObject * obj0 = 0 ;
42214 char *kwnames[] = {
42215 (char *) "self", NULL
42216 };
42217
42218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42220 if (SWIG_arg_fail(1)) SWIG_fail;
42221 {
42222 PyThreadState* __tstate = wxPyBeginAllowThreads();
42223 result = (int)(arg1)->GetFlexibleDirection();
42224
42225 wxPyEndAllowThreads(__tstate);
42226 if (PyErr_Occurred()) SWIG_fail;
42227 }
42228 {
42229 resultobj = SWIG_From_int(static_cast<int >(result));
42230 }
42231 return resultobj;
42232 fail:
42233 return NULL;
42234 }
42235
42236
42237 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42238 PyObject *resultobj = NULL;
42239 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42240 wxFlexSizerGrowMode arg2 ;
42241 PyObject * obj0 = 0 ;
42242 PyObject * obj1 = 0 ;
42243 char *kwnames[] = {
42244 (char *) "self",(char *) "mode", NULL
42245 };
42246
42247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42249 if (SWIG_arg_fail(1)) SWIG_fail;
42250 {
42251 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42252 if (SWIG_arg_fail(2)) SWIG_fail;
42253 }
42254 {
42255 PyThreadState* __tstate = wxPyBeginAllowThreads();
42256 (arg1)->SetNonFlexibleGrowMode(arg2);
42257
42258 wxPyEndAllowThreads(__tstate);
42259 if (PyErr_Occurred()) SWIG_fail;
42260 }
42261 Py_INCREF(Py_None); resultobj = Py_None;
42262 return resultobj;
42263 fail:
42264 return NULL;
42265 }
42266
42267
42268 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42269 PyObject *resultobj = NULL;
42270 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42271 wxFlexSizerGrowMode result;
42272 PyObject * obj0 = 0 ;
42273 char *kwnames[] = {
42274 (char *) "self", NULL
42275 };
42276
42277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42279 if (SWIG_arg_fail(1)) SWIG_fail;
42280 {
42281 PyThreadState* __tstate = wxPyBeginAllowThreads();
42282 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42283
42284 wxPyEndAllowThreads(__tstate);
42285 if (PyErr_Occurred()) SWIG_fail;
42286 }
42287 resultobj = SWIG_From_int((result));
42288 return resultobj;
42289 fail:
42290 return NULL;
42291 }
42292
42293
42294 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42295 PyObject *resultobj = NULL;
42296 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42297 wxArrayInt *result;
42298 PyObject * obj0 = 0 ;
42299 char *kwnames[] = {
42300 (char *) "self", NULL
42301 };
42302
42303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42305 if (SWIG_arg_fail(1)) SWIG_fail;
42306 {
42307 PyThreadState* __tstate = wxPyBeginAllowThreads();
42308 {
42309 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42310 result = (wxArrayInt *) &_result_ref;
42311 }
42312
42313 wxPyEndAllowThreads(__tstate);
42314 if (PyErr_Occurred()) SWIG_fail;
42315 }
42316 {
42317 resultobj = PyList_New(0);
42318 size_t idx;
42319 for (idx = 0; idx < result->GetCount(); idx += 1) {
42320 PyObject* val = PyInt_FromLong( result->Item(idx) );
42321 PyList_Append(resultobj, val);
42322 Py_DECREF(val);
42323 }
42324 }
42325 return resultobj;
42326 fail:
42327 return NULL;
42328 }
42329
42330
42331 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42332 PyObject *resultobj = NULL;
42333 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42334 wxArrayInt *result;
42335 PyObject * obj0 = 0 ;
42336 char *kwnames[] = {
42337 (char *) "self", NULL
42338 };
42339
42340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42342 if (SWIG_arg_fail(1)) SWIG_fail;
42343 {
42344 PyThreadState* __tstate = wxPyBeginAllowThreads();
42345 {
42346 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42347 result = (wxArrayInt *) &_result_ref;
42348 }
42349
42350 wxPyEndAllowThreads(__tstate);
42351 if (PyErr_Occurred()) SWIG_fail;
42352 }
42353 {
42354 resultobj = PyList_New(0);
42355 size_t idx;
42356 for (idx = 0; idx < result->GetCount(); idx += 1) {
42357 PyObject* val = PyInt_FromLong( result->Item(idx) );
42358 PyList_Append(resultobj, val);
42359 Py_DECREF(val);
42360 }
42361 }
42362 return resultobj;
42363 fail:
42364 return NULL;
42365 }
42366
42367
42368 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42369 PyObject *obj;
42370 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42371 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42372 Py_INCREF(obj);
42373 return Py_BuildValue((char *)"");
42374 }
42375 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42376 PyObject *resultobj = NULL;
42377 wxStdDialogButtonSizer *result;
42378 char *kwnames[] = {
42379 NULL
42380 };
42381
42382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42383 {
42384 PyThreadState* __tstate = wxPyBeginAllowThreads();
42385 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42386
42387 wxPyEndAllowThreads(__tstate);
42388 if (PyErr_Occurred()) SWIG_fail;
42389 }
42390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42391 return resultobj;
42392 fail:
42393 return NULL;
42394 }
42395
42396
42397 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42398 PyObject *resultobj = NULL;
42399 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42400 wxButton *arg2 = (wxButton *) 0 ;
42401 PyObject * obj0 = 0 ;
42402 PyObject * obj1 = 0 ;
42403 char *kwnames[] = {
42404 (char *) "self",(char *) "button", NULL
42405 };
42406
42407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42409 if (SWIG_arg_fail(1)) SWIG_fail;
42410 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42411 if (SWIG_arg_fail(2)) SWIG_fail;
42412 {
42413 PyThreadState* __tstate = wxPyBeginAllowThreads();
42414 (arg1)->AddButton(arg2);
42415
42416 wxPyEndAllowThreads(__tstate);
42417 if (PyErr_Occurred()) SWIG_fail;
42418 }
42419 Py_INCREF(Py_None); resultobj = Py_None;
42420 return resultobj;
42421 fail:
42422 return NULL;
42423 }
42424
42425
42426 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42427 PyObject *resultobj = NULL;
42428 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42429 PyObject * obj0 = 0 ;
42430 char *kwnames[] = {
42431 (char *) "self", NULL
42432 };
42433
42434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42436 if (SWIG_arg_fail(1)) SWIG_fail;
42437 {
42438 PyThreadState* __tstate = wxPyBeginAllowThreads();
42439 (arg1)->Realize();
42440
42441 wxPyEndAllowThreads(__tstate);
42442 if (PyErr_Occurred()) SWIG_fail;
42443 }
42444 Py_INCREF(Py_None); resultobj = Py_None;
42445 return resultobj;
42446 fail:
42447 return NULL;
42448 }
42449
42450
42451 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42452 PyObject *resultobj = NULL;
42453 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42454 wxButton *arg2 = (wxButton *) 0 ;
42455 PyObject * obj0 = 0 ;
42456 PyObject * obj1 = 0 ;
42457 char *kwnames[] = {
42458 (char *) "self",(char *) "button", NULL
42459 };
42460
42461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42463 if (SWIG_arg_fail(1)) SWIG_fail;
42464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42465 if (SWIG_arg_fail(2)) SWIG_fail;
42466 {
42467 PyThreadState* __tstate = wxPyBeginAllowThreads();
42468 (arg1)->SetAffirmativeButton(arg2);
42469
42470 wxPyEndAllowThreads(__tstate);
42471 if (PyErr_Occurred()) SWIG_fail;
42472 }
42473 Py_INCREF(Py_None); resultobj = Py_None;
42474 return resultobj;
42475 fail:
42476 return NULL;
42477 }
42478
42479
42480 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42481 PyObject *resultobj = NULL;
42482 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42483 wxButton *arg2 = (wxButton *) 0 ;
42484 PyObject * obj0 = 0 ;
42485 PyObject * obj1 = 0 ;
42486 char *kwnames[] = {
42487 (char *) "self",(char *) "button", NULL
42488 };
42489
42490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42492 if (SWIG_arg_fail(1)) SWIG_fail;
42493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42494 if (SWIG_arg_fail(2)) SWIG_fail;
42495 {
42496 PyThreadState* __tstate = wxPyBeginAllowThreads();
42497 (arg1)->SetNegativeButton(arg2);
42498
42499 wxPyEndAllowThreads(__tstate);
42500 if (PyErr_Occurred()) SWIG_fail;
42501 }
42502 Py_INCREF(Py_None); resultobj = Py_None;
42503 return resultobj;
42504 fail:
42505 return NULL;
42506 }
42507
42508
42509 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42510 PyObject *resultobj = NULL;
42511 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42512 wxButton *arg2 = (wxButton *) 0 ;
42513 PyObject * obj0 = 0 ;
42514 PyObject * obj1 = 0 ;
42515 char *kwnames[] = {
42516 (char *) "self",(char *) "button", NULL
42517 };
42518
42519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42521 if (SWIG_arg_fail(1)) SWIG_fail;
42522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42523 if (SWIG_arg_fail(2)) SWIG_fail;
42524 {
42525 PyThreadState* __tstate = wxPyBeginAllowThreads();
42526 (arg1)->SetCancelButton(arg2);
42527
42528 wxPyEndAllowThreads(__tstate);
42529 if (PyErr_Occurred()) SWIG_fail;
42530 }
42531 Py_INCREF(Py_None); resultobj = Py_None;
42532 return resultobj;
42533 fail:
42534 return NULL;
42535 }
42536
42537
42538 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42539 PyObject *resultobj = NULL;
42540 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42541 wxButton *result;
42542 PyObject * obj0 = 0 ;
42543 char *kwnames[] = {
42544 (char *) "self", NULL
42545 };
42546
42547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42549 if (SWIG_arg_fail(1)) SWIG_fail;
42550 {
42551 PyThreadState* __tstate = wxPyBeginAllowThreads();
42552 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42553
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 {
42558 resultobj = wxPyMake_wxObject(result, (bool)0);
42559 }
42560 return resultobj;
42561 fail:
42562 return NULL;
42563 }
42564
42565
42566 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42567 PyObject *resultobj = NULL;
42568 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42569 wxButton *result;
42570 PyObject * obj0 = 0 ;
42571 char *kwnames[] = {
42572 (char *) "self", NULL
42573 };
42574
42575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42577 if (SWIG_arg_fail(1)) SWIG_fail;
42578 {
42579 PyThreadState* __tstate = wxPyBeginAllowThreads();
42580 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42581
42582 wxPyEndAllowThreads(__tstate);
42583 if (PyErr_Occurred()) SWIG_fail;
42584 }
42585 {
42586 resultobj = wxPyMake_wxObject(result, (bool)0);
42587 }
42588 return resultobj;
42589 fail:
42590 return NULL;
42591 }
42592
42593
42594 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42595 PyObject *resultobj = NULL;
42596 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42597 wxButton *result;
42598 PyObject * obj0 = 0 ;
42599 char *kwnames[] = {
42600 (char *) "self", NULL
42601 };
42602
42603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42605 if (SWIG_arg_fail(1)) SWIG_fail;
42606 {
42607 PyThreadState* __tstate = wxPyBeginAllowThreads();
42608 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42609
42610 wxPyEndAllowThreads(__tstate);
42611 if (PyErr_Occurred()) SWIG_fail;
42612 }
42613 {
42614 resultobj = wxPyMake_wxObject(result, (bool)0);
42615 }
42616 return resultobj;
42617 fail:
42618 return NULL;
42619 }
42620
42621
42622 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42623 PyObject *resultobj = NULL;
42624 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42625 wxButton *result;
42626 PyObject * obj0 = 0 ;
42627 char *kwnames[] = {
42628 (char *) "self", NULL
42629 };
42630
42631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42633 if (SWIG_arg_fail(1)) SWIG_fail;
42634 {
42635 PyThreadState* __tstate = wxPyBeginAllowThreads();
42636 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42637
42638 wxPyEndAllowThreads(__tstate);
42639 if (PyErr_Occurred()) SWIG_fail;
42640 }
42641 {
42642 resultobj = wxPyMake_wxObject(result, (bool)0);
42643 }
42644 return resultobj;
42645 fail:
42646 return NULL;
42647 }
42648
42649
42650 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42651 PyObject *resultobj = NULL;
42652 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42653 wxButton *result;
42654 PyObject * obj0 = 0 ;
42655 char *kwnames[] = {
42656 (char *) "self", NULL
42657 };
42658
42659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42661 if (SWIG_arg_fail(1)) SWIG_fail;
42662 {
42663 PyThreadState* __tstate = wxPyBeginAllowThreads();
42664 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42665
42666 wxPyEndAllowThreads(__tstate);
42667 if (PyErr_Occurred()) SWIG_fail;
42668 }
42669 {
42670 resultobj = wxPyMake_wxObject(result, (bool)0);
42671 }
42672 return resultobj;
42673 fail:
42674 return NULL;
42675 }
42676
42677
42678 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42679 PyObject *obj;
42680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42681 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42682 Py_INCREF(obj);
42683 return Py_BuildValue((char *)"");
42684 }
42685 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42686 PyObject *resultobj = NULL;
42687 int arg1 = (int) 0 ;
42688 int arg2 = (int) 0 ;
42689 wxGBPosition *result;
42690 PyObject * obj0 = 0 ;
42691 PyObject * obj1 = 0 ;
42692 char *kwnames[] = {
42693 (char *) "row",(char *) "col", NULL
42694 };
42695
42696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42697 if (obj0) {
42698 {
42699 arg1 = static_cast<int >(SWIG_As_int(obj0));
42700 if (SWIG_arg_fail(1)) SWIG_fail;
42701 }
42702 }
42703 if (obj1) {
42704 {
42705 arg2 = static_cast<int >(SWIG_As_int(obj1));
42706 if (SWIG_arg_fail(2)) SWIG_fail;
42707 }
42708 }
42709 {
42710 PyThreadState* __tstate = wxPyBeginAllowThreads();
42711 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42712
42713 wxPyEndAllowThreads(__tstate);
42714 if (PyErr_Occurred()) SWIG_fail;
42715 }
42716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42717 return resultobj;
42718 fail:
42719 return NULL;
42720 }
42721
42722
42723 static PyObject *_wrap_delete_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42724 PyObject *resultobj = NULL;
42725 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42726 PyObject * obj0 = 0 ;
42727 char *kwnames[] = {
42728 (char *) "self", NULL
42729 };
42730
42731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBPosition",kwnames,&obj0)) goto fail;
42732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42733 if (SWIG_arg_fail(1)) SWIG_fail;
42734 {
42735 PyThreadState* __tstate = wxPyBeginAllowThreads();
42736 delete arg1;
42737
42738 wxPyEndAllowThreads(__tstate);
42739 if (PyErr_Occurred()) SWIG_fail;
42740 }
42741 Py_INCREF(Py_None); resultobj = Py_None;
42742 return resultobj;
42743 fail:
42744 return NULL;
42745 }
42746
42747
42748 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42749 PyObject *resultobj = NULL;
42750 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42751 int result;
42752 PyObject * obj0 = 0 ;
42753 char *kwnames[] = {
42754 (char *) "self", NULL
42755 };
42756
42757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42759 if (SWIG_arg_fail(1)) SWIG_fail;
42760 {
42761 PyThreadState* __tstate = wxPyBeginAllowThreads();
42762 result = (int)((wxGBPosition const *)arg1)->GetRow();
42763
42764 wxPyEndAllowThreads(__tstate);
42765 if (PyErr_Occurred()) SWIG_fail;
42766 }
42767 {
42768 resultobj = SWIG_From_int(static_cast<int >(result));
42769 }
42770 return resultobj;
42771 fail:
42772 return NULL;
42773 }
42774
42775
42776 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42777 PyObject *resultobj = NULL;
42778 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42779 int result;
42780 PyObject * obj0 = 0 ;
42781 char *kwnames[] = {
42782 (char *) "self", NULL
42783 };
42784
42785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42787 if (SWIG_arg_fail(1)) SWIG_fail;
42788 {
42789 PyThreadState* __tstate = wxPyBeginAllowThreads();
42790 result = (int)((wxGBPosition const *)arg1)->GetCol();
42791
42792 wxPyEndAllowThreads(__tstate);
42793 if (PyErr_Occurred()) SWIG_fail;
42794 }
42795 {
42796 resultobj = SWIG_From_int(static_cast<int >(result));
42797 }
42798 return resultobj;
42799 fail:
42800 return NULL;
42801 }
42802
42803
42804 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42805 PyObject *resultobj = NULL;
42806 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42807 int arg2 ;
42808 PyObject * obj0 = 0 ;
42809 PyObject * obj1 = 0 ;
42810 char *kwnames[] = {
42811 (char *) "self",(char *) "row", NULL
42812 };
42813
42814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42816 if (SWIG_arg_fail(1)) SWIG_fail;
42817 {
42818 arg2 = static_cast<int >(SWIG_As_int(obj1));
42819 if (SWIG_arg_fail(2)) SWIG_fail;
42820 }
42821 {
42822 PyThreadState* __tstate = wxPyBeginAllowThreads();
42823 (arg1)->SetRow(arg2);
42824
42825 wxPyEndAllowThreads(__tstate);
42826 if (PyErr_Occurred()) SWIG_fail;
42827 }
42828 Py_INCREF(Py_None); resultobj = Py_None;
42829 return resultobj;
42830 fail:
42831 return NULL;
42832 }
42833
42834
42835 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42836 PyObject *resultobj = NULL;
42837 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42838 int arg2 ;
42839 PyObject * obj0 = 0 ;
42840 PyObject * obj1 = 0 ;
42841 char *kwnames[] = {
42842 (char *) "self",(char *) "col", NULL
42843 };
42844
42845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42847 if (SWIG_arg_fail(1)) SWIG_fail;
42848 {
42849 arg2 = static_cast<int >(SWIG_As_int(obj1));
42850 if (SWIG_arg_fail(2)) SWIG_fail;
42851 }
42852 {
42853 PyThreadState* __tstate = wxPyBeginAllowThreads();
42854 (arg1)->SetCol(arg2);
42855
42856 wxPyEndAllowThreads(__tstate);
42857 if (PyErr_Occurred()) SWIG_fail;
42858 }
42859 Py_INCREF(Py_None); resultobj = Py_None;
42860 return resultobj;
42861 fail:
42862 return NULL;
42863 }
42864
42865
42866 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42867 PyObject *resultobj = NULL;
42868 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42869 wxGBPosition *arg2 = 0 ;
42870 bool result;
42871 wxGBPosition temp2 ;
42872 PyObject * obj0 = 0 ;
42873 PyObject * obj1 = 0 ;
42874 char *kwnames[] = {
42875 (char *) "self",(char *) "other", NULL
42876 };
42877
42878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42880 if (SWIG_arg_fail(1)) SWIG_fail;
42881 {
42882 arg2 = &temp2;
42883 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42884 }
42885 {
42886 PyThreadState* __tstate = wxPyBeginAllowThreads();
42887 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42888
42889 wxPyEndAllowThreads(__tstate);
42890 if (PyErr_Occurred()) SWIG_fail;
42891 }
42892 {
42893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42894 }
42895 return resultobj;
42896 fail:
42897 return NULL;
42898 }
42899
42900
42901 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42902 PyObject *resultobj = NULL;
42903 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42904 wxGBPosition *arg2 = 0 ;
42905 bool result;
42906 wxGBPosition temp2 ;
42907 PyObject * obj0 = 0 ;
42908 PyObject * obj1 = 0 ;
42909 char *kwnames[] = {
42910 (char *) "self",(char *) "other", NULL
42911 };
42912
42913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42915 if (SWIG_arg_fail(1)) SWIG_fail;
42916 {
42917 arg2 = &temp2;
42918 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42919 }
42920 {
42921 PyThreadState* __tstate = wxPyBeginAllowThreads();
42922 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42923
42924 wxPyEndAllowThreads(__tstate);
42925 if (PyErr_Occurred()) SWIG_fail;
42926 }
42927 {
42928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42929 }
42930 return resultobj;
42931 fail:
42932 return NULL;
42933 }
42934
42935
42936 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42937 PyObject *resultobj = NULL;
42938 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42939 int arg2 = (int) 0 ;
42940 int arg3 = (int) 0 ;
42941 PyObject * obj0 = 0 ;
42942 PyObject * obj1 = 0 ;
42943 PyObject * obj2 = 0 ;
42944 char *kwnames[] = {
42945 (char *) "self",(char *) "row",(char *) "col", NULL
42946 };
42947
42948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42950 if (SWIG_arg_fail(1)) SWIG_fail;
42951 if (obj1) {
42952 {
42953 arg2 = static_cast<int >(SWIG_As_int(obj1));
42954 if (SWIG_arg_fail(2)) SWIG_fail;
42955 }
42956 }
42957 if (obj2) {
42958 {
42959 arg3 = static_cast<int >(SWIG_As_int(obj2));
42960 if (SWIG_arg_fail(3)) SWIG_fail;
42961 }
42962 }
42963 {
42964 PyThreadState* __tstate = wxPyBeginAllowThreads();
42965 wxGBPosition_Set(arg1,arg2,arg3);
42966
42967 wxPyEndAllowThreads(__tstate);
42968 if (PyErr_Occurred()) SWIG_fail;
42969 }
42970 Py_INCREF(Py_None); resultobj = Py_None;
42971 return resultobj;
42972 fail:
42973 return NULL;
42974 }
42975
42976
42977 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42978 PyObject *resultobj = NULL;
42979 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42980 PyObject *result;
42981 PyObject * obj0 = 0 ;
42982 char *kwnames[] = {
42983 (char *) "self", NULL
42984 };
42985
42986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42988 if (SWIG_arg_fail(1)) SWIG_fail;
42989 {
42990 PyThreadState* __tstate = wxPyBeginAllowThreads();
42991 result = (PyObject *)wxGBPosition_Get(arg1);
42992
42993 wxPyEndAllowThreads(__tstate);
42994 if (PyErr_Occurred()) SWIG_fail;
42995 }
42996 resultobj = result;
42997 return resultobj;
42998 fail:
42999 return NULL;
43000 }
43001
43002
43003 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
43004 PyObject *obj;
43005 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43006 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
43007 Py_INCREF(obj);
43008 return Py_BuildValue((char *)"");
43009 }
43010 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43011 PyObject *resultobj = NULL;
43012 int arg1 = (int) 1 ;
43013 int arg2 = (int) 1 ;
43014 wxGBSpan *result;
43015 PyObject * obj0 = 0 ;
43016 PyObject * obj1 = 0 ;
43017 char *kwnames[] = {
43018 (char *) "rowspan",(char *) "colspan", NULL
43019 };
43020
43021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
43022 if (obj0) {
43023 {
43024 arg1 = static_cast<int >(SWIG_As_int(obj0));
43025 if (SWIG_arg_fail(1)) SWIG_fail;
43026 }
43027 }
43028 if (obj1) {
43029 {
43030 arg2 = static_cast<int >(SWIG_As_int(obj1));
43031 if (SWIG_arg_fail(2)) SWIG_fail;
43032 }
43033 }
43034 {
43035 PyThreadState* __tstate = wxPyBeginAllowThreads();
43036 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
43037
43038 wxPyEndAllowThreads(__tstate);
43039 if (PyErr_Occurred()) SWIG_fail;
43040 }
43041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
43042 return resultobj;
43043 fail:
43044 return NULL;
43045 }
43046
43047
43048 static PyObject *_wrap_delete_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43049 PyObject *resultobj = NULL;
43050 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43051 PyObject * obj0 = 0 ;
43052 char *kwnames[] = {
43053 (char *) "self", NULL
43054 };
43055
43056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSpan",kwnames,&obj0)) goto fail;
43057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43058 if (SWIG_arg_fail(1)) SWIG_fail;
43059 {
43060 PyThreadState* __tstate = wxPyBeginAllowThreads();
43061 delete arg1;
43062
43063 wxPyEndAllowThreads(__tstate);
43064 if (PyErr_Occurred()) SWIG_fail;
43065 }
43066 Py_INCREF(Py_None); resultobj = Py_None;
43067 return resultobj;
43068 fail:
43069 return NULL;
43070 }
43071
43072
43073 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43074 PyObject *resultobj = NULL;
43075 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43076 int result;
43077 PyObject * obj0 = 0 ;
43078 char *kwnames[] = {
43079 (char *) "self", NULL
43080 };
43081
43082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
43083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43084 if (SWIG_arg_fail(1)) SWIG_fail;
43085 {
43086 PyThreadState* __tstate = wxPyBeginAllowThreads();
43087 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
43088
43089 wxPyEndAllowThreads(__tstate);
43090 if (PyErr_Occurred()) SWIG_fail;
43091 }
43092 {
43093 resultobj = SWIG_From_int(static_cast<int >(result));
43094 }
43095 return resultobj;
43096 fail:
43097 return NULL;
43098 }
43099
43100
43101 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43102 PyObject *resultobj = NULL;
43103 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43104 int result;
43105 PyObject * obj0 = 0 ;
43106 char *kwnames[] = {
43107 (char *) "self", NULL
43108 };
43109
43110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43112 if (SWIG_arg_fail(1)) SWIG_fail;
43113 {
43114 PyThreadState* __tstate = wxPyBeginAllowThreads();
43115 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43116
43117 wxPyEndAllowThreads(__tstate);
43118 if (PyErr_Occurred()) SWIG_fail;
43119 }
43120 {
43121 resultobj = SWIG_From_int(static_cast<int >(result));
43122 }
43123 return resultobj;
43124 fail:
43125 return NULL;
43126 }
43127
43128
43129 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43130 PyObject *resultobj = NULL;
43131 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43132 int arg2 ;
43133 PyObject * obj0 = 0 ;
43134 PyObject * obj1 = 0 ;
43135 char *kwnames[] = {
43136 (char *) "self",(char *) "rowspan", NULL
43137 };
43138
43139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43141 if (SWIG_arg_fail(1)) SWIG_fail;
43142 {
43143 arg2 = static_cast<int >(SWIG_As_int(obj1));
43144 if (SWIG_arg_fail(2)) SWIG_fail;
43145 }
43146 {
43147 PyThreadState* __tstate = wxPyBeginAllowThreads();
43148 (arg1)->SetRowspan(arg2);
43149
43150 wxPyEndAllowThreads(__tstate);
43151 if (PyErr_Occurred()) SWIG_fail;
43152 }
43153 Py_INCREF(Py_None); resultobj = Py_None;
43154 return resultobj;
43155 fail:
43156 return NULL;
43157 }
43158
43159
43160 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43161 PyObject *resultobj = NULL;
43162 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43163 int arg2 ;
43164 PyObject * obj0 = 0 ;
43165 PyObject * obj1 = 0 ;
43166 char *kwnames[] = {
43167 (char *) "self",(char *) "colspan", NULL
43168 };
43169
43170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43172 if (SWIG_arg_fail(1)) SWIG_fail;
43173 {
43174 arg2 = static_cast<int >(SWIG_As_int(obj1));
43175 if (SWIG_arg_fail(2)) SWIG_fail;
43176 }
43177 {
43178 PyThreadState* __tstate = wxPyBeginAllowThreads();
43179 (arg1)->SetColspan(arg2);
43180
43181 wxPyEndAllowThreads(__tstate);
43182 if (PyErr_Occurred()) SWIG_fail;
43183 }
43184 Py_INCREF(Py_None); resultobj = Py_None;
43185 return resultobj;
43186 fail:
43187 return NULL;
43188 }
43189
43190
43191 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43192 PyObject *resultobj = NULL;
43193 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43194 wxGBSpan *arg2 = 0 ;
43195 bool result;
43196 wxGBSpan temp2 ;
43197 PyObject * obj0 = 0 ;
43198 PyObject * obj1 = 0 ;
43199 char *kwnames[] = {
43200 (char *) "self",(char *) "other", NULL
43201 };
43202
43203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43205 if (SWIG_arg_fail(1)) SWIG_fail;
43206 {
43207 arg2 = &temp2;
43208 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43209 }
43210 {
43211 PyThreadState* __tstate = wxPyBeginAllowThreads();
43212 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43213
43214 wxPyEndAllowThreads(__tstate);
43215 if (PyErr_Occurred()) SWIG_fail;
43216 }
43217 {
43218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43219 }
43220 return resultobj;
43221 fail:
43222 return NULL;
43223 }
43224
43225
43226 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43227 PyObject *resultobj = NULL;
43228 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43229 wxGBSpan *arg2 = 0 ;
43230 bool result;
43231 wxGBSpan temp2 ;
43232 PyObject * obj0 = 0 ;
43233 PyObject * obj1 = 0 ;
43234 char *kwnames[] = {
43235 (char *) "self",(char *) "other", NULL
43236 };
43237
43238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43240 if (SWIG_arg_fail(1)) SWIG_fail;
43241 {
43242 arg2 = &temp2;
43243 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43244 }
43245 {
43246 PyThreadState* __tstate = wxPyBeginAllowThreads();
43247 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43248
43249 wxPyEndAllowThreads(__tstate);
43250 if (PyErr_Occurred()) SWIG_fail;
43251 }
43252 {
43253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43254 }
43255 return resultobj;
43256 fail:
43257 return NULL;
43258 }
43259
43260
43261 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43262 PyObject *resultobj = NULL;
43263 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43264 int arg2 = (int) 1 ;
43265 int arg3 = (int) 1 ;
43266 PyObject * obj0 = 0 ;
43267 PyObject * obj1 = 0 ;
43268 PyObject * obj2 = 0 ;
43269 char *kwnames[] = {
43270 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43271 };
43272
43273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43275 if (SWIG_arg_fail(1)) SWIG_fail;
43276 if (obj1) {
43277 {
43278 arg2 = static_cast<int >(SWIG_As_int(obj1));
43279 if (SWIG_arg_fail(2)) SWIG_fail;
43280 }
43281 }
43282 if (obj2) {
43283 {
43284 arg3 = static_cast<int >(SWIG_As_int(obj2));
43285 if (SWIG_arg_fail(3)) SWIG_fail;
43286 }
43287 }
43288 {
43289 PyThreadState* __tstate = wxPyBeginAllowThreads();
43290 wxGBSpan_Set(arg1,arg2,arg3);
43291
43292 wxPyEndAllowThreads(__tstate);
43293 if (PyErr_Occurred()) SWIG_fail;
43294 }
43295 Py_INCREF(Py_None); resultobj = Py_None;
43296 return resultobj;
43297 fail:
43298 return NULL;
43299 }
43300
43301
43302 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43303 PyObject *resultobj = NULL;
43304 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43305 PyObject *result;
43306 PyObject * obj0 = 0 ;
43307 char *kwnames[] = {
43308 (char *) "self", NULL
43309 };
43310
43311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43313 if (SWIG_arg_fail(1)) SWIG_fail;
43314 {
43315 PyThreadState* __tstate = wxPyBeginAllowThreads();
43316 result = (PyObject *)wxGBSpan_Get(arg1);
43317
43318 wxPyEndAllowThreads(__tstate);
43319 if (PyErr_Occurred()) SWIG_fail;
43320 }
43321 resultobj = result;
43322 return resultobj;
43323 fail:
43324 return NULL;
43325 }
43326
43327
43328 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43329 PyObject *obj;
43330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43331 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43332 Py_INCREF(obj);
43333 return Py_BuildValue((char *)"");
43334 }
43335 static int _wrap_DefaultSpan_set(PyObject *) {
43336 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43337 return 1;
43338 }
43339
43340
43341 static PyObject *_wrap_DefaultSpan_get(void) {
43342 PyObject *pyobj = NULL;
43343
43344 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43345 return pyobj;
43346 }
43347
43348
43349 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43350 PyObject *resultobj = NULL;
43351 wxGBSizerItem *result;
43352 char *kwnames[] = {
43353 NULL
43354 };
43355
43356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43357 {
43358 PyThreadState* __tstate = wxPyBeginAllowThreads();
43359 result = (wxGBSizerItem *)new wxGBSizerItem();
43360
43361 wxPyEndAllowThreads(__tstate);
43362 if (PyErr_Occurred()) SWIG_fail;
43363 }
43364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43365 return resultobj;
43366 fail:
43367 return NULL;
43368 }
43369
43370
43371 static PyObject *_wrap_delete_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43372 PyObject *resultobj = NULL;
43373 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43374 PyObject * obj0 = 0 ;
43375 char *kwnames[] = {
43376 (char *) "self", NULL
43377 };
43378
43379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSizerItem",kwnames,&obj0)) goto fail;
43380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43381 if (SWIG_arg_fail(1)) SWIG_fail;
43382 {
43383 PyThreadState* __tstate = wxPyBeginAllowThreads();
43384 delete arg1;
43385
43386 wxPyEndAllowThreads(__tstate);
43387 if (PyErr_Occurred()) SWIG_fail;
43388 }
43389 Py_INCREF(Py_None); resultobj = Py_None;
43390 return resultobj;
43391 fail:
43392 return NULL;
43393 }
43394
43395
43396 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43397 PyObject *resultobj = NULL;
43398 wxWindow *arg1 = (wxWindow *) 0 ;
43399 wxGBPosition *arg2 = 0 ;
43400 wxGBSpan *arg3 = 0 ;
43401 int arg4 ;
43402 int arg5 ;
43403 PyObject *arg6 = (PyObject *) NULL ;
43404 wxGBSizerItem *result;
43405 wxGBPosition temp2 ;
43406 wxGBSpan temp3 ;
43407 PyObject * obj0 = 0 ;
43408 PyObject * obj1 = 0 ;
43409 PyObject * obj2 = 0 ;
43410 PyObject * obj3 = 0 ;
43411 PyObject * obj4 = 0 ;
43412 PyObject * obj5 = 0 ;
43413 char *kwnames[] = {
43414 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43415 };
43416
43417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43419 if (SWIG_arg_fail(1)) SWIG_fail;
43420 {
43421 arg2 = &temp2;
43422 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43423 }
43424 {
43425 arg3 = &temp3;
43426 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43427 }
43428 {
43429 arg4 = static_cast<int >(SWIG_As_int(obj3));
43430 if (SWIG_arg_fail(4)) SWIG_fail;
43431 }
43432 {
43433 arg5 = static_cast<int >(SWIG_As_int(obj4));
43434 if (SWIG_arg_fail(5)) SWIG_fail;
43435 }
43436 if (obj5) {
43437 arg6 = obj5;
43438 }
43439 {
43440 PyThreadState* __tstate = wxPyBeginAllowThreads();
43441 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43442
43443 wxPyEndAllowThreads(__tstate);
43444 if (PyErr_Occurred()) SWIG_fail;
43445 }
43446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43447 return resultobj;
43448 fail:
43449 return NULL;
43450 }
43451
43452
43453 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43454 PyObject *resultobj = NULL;
43455 wxSizer *arg1 = (wxSizer *) 0 ;
43456 wxGBPosition *arg2 = 0 ;
43457 wxGBSpan *arg3 = 0 ;
43458 int arg4 ;
43459 int arg5 ;
43460 PyObject *arg6 = (PyObject *) NULL ;
43461 wxGBSizerItem *result;
43462 wxGBPosition temp2 ;
43463 wxGBSpan temp3 ;
43464 PyObject * obj0 = 0 ;
43465 PyObject * obj1 = 0 ;
43466 PyObject * obj2 = 0 ;
43467 PyObject * obj3 = 0 ;
43468 PyObject * obj4 = 0 ;
43469 PyObject * obj5 = 0 ;
43470 char *kwnames[] = {
43471 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43472 };
43473
43474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
43476 if (SWIG_arg_fail(1)) SWIG_fail;
43477 {
43478 arg2 = &temp2;
43479 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43480 }
43481 {
43482 arg3 = &temp3;
43483 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43484 }
43485 {
43486 arg4 = static_cast<int >(SWIG_As_int(obj3));
43487 if (SWIG_arg_fail(4)) SWIG_fail;
43488 }
43489 {
43490 arg5 = static_cast<int >(SWIG_As_int(obj4));
43491 if (SWIG_arg_fail(5)) SWIG_fail;
43492 }
43493 if (obj5) {
43494 arg6 = obj5;
43495 }
43496 {
43497 PyThreadState* __tstate = wxPyBeginAllowThreads();
43498 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43499
43500 wxPyEndAllowThreads(__tstate);
43501 if (PyErr_Occurred()) SWIG_fail;
43502 }
43503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43504 return resultobj;
43505 fail:
43506 return NULL;
43507 }
43508
43509
43510 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43511 PyObject *resultobj = NULL;
43512 int arg1 ;
43513 int arg2 ;
43514 wxGBPosition *arg3 = 0 ;
43515 wxGBSpan *arg4 = 0 ;
43516 int arg5 ;
43517 int arg6 ;
43518 PyObject *arg7 = (PyObject *) NULL ;
43519 wxGBSizerItem *result;
43520 wxGBPosition temp3 ;
43521 wxGBSpan temp4 ;
43522 PyObject * obj0 = 0 ;
43523 PyObject * obj1 = 0 ;
43524 PyObject * obj2 = 0 ;
43525 PyObject * obj3 = 0 ;
43526 PyObject * obj4 = 0 ;
43527 PyObject * obj5 = 0 ;
43528 PyObject * obj6 = 0 ;
43529 char *kwnames[] = {
43530 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43531 };
43532
43533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43534 {
43535 arg1 = static_cast<int >(SWIG_As_int(obj0));
43536 if (SWIG_arg_fail(1)) SWIG_fail;
43537 }
43538 {
43539 arg2 = static_cast<int >(SWIG_As_int(obj1));
43540 if (SWIG_arg_fail(2)) SWIG_fail;
43541 }
43542 {
43543 arg3 = &temp3;
43544 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43545 }
43546 {
43547 arg4 = &temp4;
43548 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43549 }
43550 {
43551 arg5 = static_cast<int >(SWIG_As_int(obj4));
43552 if (SWIG_arg_fail(5)) SWIG_fail;
43553 }
43554 {
43555 arg6 = static_cast<int >(SWIG_As_int(obj5));
43556 if (SWIG_arg_fail(6)) SWIG_fail;
43557 }
43558 if (obj6) {
43559 arg7 = obj6;
43560 }
43561 {
43562 PyThreadState* __tstate = wxPyBeginAllowThreads();
43563 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43564
43565 wxPyEndAllowThreads(__tstate);
43566 if (PyErr_Occurred()) SWIG_fail;
43567 }
43568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43569 return resultobj;
43570 fail:
43571 return NULL;
43572 }
43573
43574
43575 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43576 PyObject *resultobj = NULL;
43577 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43578 wxGBPosition result;
43579 PyObject * obj0 = 0 ;
43580 char *kwnames[] = {
43581 (char *) "self", NULL
43582 };
43583
43584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43586 if (SWIG_arg_fail(1)) SWIG_fail;
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 result = ((wxGBSizerItem const *)arg1)->GetPos();
43590
43591 wxPyEndAllowThreads(__tstate);
43592 if (PyErr_Occurred()) SWIG_fail;
43593 }
43594 {
43595 wxGBPosition * resultptr;
43596 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43598 }
43599 return resultobj;
43600 fail:
43601 return NULL;
43602 }
43603
43604
43605 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43606 PyObject *resultobj = NULL;
43607 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43608 wxGBSpan result;
43609 PyObject * obj0 = 0 ;
43610 char *kwnames[] = {
43611 (char *) "self", NULL
43612 };
43613
43614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43616 if (SWIG_arg_fail(1)) SWIG_fail;
43617 {
43618 PyThreadState* __tstate = wxPyBeginAllowThreads();
43619 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43620
43621 wxPyEndAllowThreads(__tstate);
43622 if (PyErr_Occurred()) SWIG_fail;
43623 }
43624 {
43625 wxGBSpan * resultptr;
43626 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43628 }
43629 return resultobj;
43630 fail:
43631 return NULL;
43632 }
43633
43634
43635 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43636 PyObject *resultobj = NULL;
43637 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43638 wxGBPosition *arg2 = 0 ;
43639 bool result;
43640 wxGBPosition temp2 ;
43641 PyObject * obj0 = 0 ;
43642 PyObject * obj1 = 0 ;
43643 char *kwnames[] = {
43644 (char *) "self",(char *) "pos", NULL
43645 };
43646
43647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43649 if (SWIG_arg_fail(1)) SWIG_fail;
43650 {
43651 arg2 = &temp2;
43652 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43653 }
43654 {
43655 PyThreadState* __tstate = wxPyBeginAllowThreads();
43656 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43657
43658 wxPyEndAllowThreads(__tstate);
43659 if (PyErr_Occurred()) SWIG_fail;
43660 }
43661 {
43662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43663 }
43664 return resultobj;
43665 fail:
43666 return NULL;
43667 }
43668
43669
43670 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43671 PyObject *resultobj = NULL;
43672 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43673 wxGBSpan *arg2 = 0 ;
43674 bool result;
43675 wxGBSpan temp2 ;
43676 PyObject * obj0 = 0 ;
43677 PyObject * obj1 = 0 ;
43678 char *kwnames[] = {
43679 (char *) "self",(char *) "span", NULL
43680 };
43681
43682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43684 if (SWIG_arg_fail(1)) SWIG_fail;
43685 {
43686 arg2 = &temp2;
43687 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43688 }
43689 {
43690 PyThreadState* __tstate = wxPyBeginAllowThreads();
43691 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43692
43693 wxPyEndAllowThreads(__tstate);
43694 if (PyErr_Occurred()) SWIG_fail;
43695 }
43696 {
43697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43698 }
43699 return resultobj;
43700 fail:
43701 return NULL;
43702 }
43703
43704
43705 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43706 PyObject *resultobj = NULL;
43707 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43708 wxGBSizerItem *arg2 = 0 ;
43709 bool result;
43710 PyObject * obj0 = 0 ;
43711 PyObject * obj1 = 0 ;
43712 char *kwnames[] = {
43713 (char *) "self",(char *) "other", NULL
43714 };
43715
43716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43718 if (SWIG_arg_fail(1)) SWIG_fail;
43719 {
43720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43721 if (SWIG_arg_fail(2)) SWIG_fail;
43722 if (arg2 == NULL) {
43723 SWIG_null_ref("wxGBSizerItem");
43724 }
43725 if (SWIG_arg_fail(2)) SWIG_fail;
43726 }
43727 {
43728 PyThreadState* __tstate = wxPyBeginAllowThreads();
43729 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43730
43731 wxPyEndAllowThreads(__tstate);
43732 if (PyErr_Occurred()) SWIG_fail;
43733 }
43734 {
43735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43736 }
43737 return resultobj;
43738 fail:
43739 return NULL;
43740 }
43741
43742
43743 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43744 PyObject *resultobj = NULL;
43745 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43746 wxGBPosition *arg2 = 0 ;
43747 wxGBSpan *arg3 = 0 ;
43748 bool result;
43749 wxGBPosition temp2 ;
43750 wxGBSpan temp3 ;
43751 PyObject * obj0 = 0 ;
43752 PyObject * obj1 = 0 ;
43753 PyObject * obj2 = 0 ;
43754 char *kwnames[] = {
43755 (char *) "self",(char *) "pos",(char *) "span", NULL
43756 };
43757
43758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43760 if (SWIG_arg_fail(1)) SWIG_fail;
43761 {
43762 arg2 = &temp2;
43763 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43764 }
43765 {
43766 arg3 = &temp3;
43767 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43768 }
43769 {
43770 PyThreadState* __tstate = wxPyBeginAllowThreads();
43771 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43772
43773 wxPyEndAllowThreads(__tstate);
43774 if (PyErr_Occurred()) SWIG_fail;
43775 }
43776 {
43777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43778 }
43779 return resultobj;
43780 fail:
43781 return NULL;
43782 }
43783
43784
43785 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43786 PyObject *resultobj = NULL;
43787 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43788 wxGBPosition result;
43789 PyObject * obj0 = 0 ;
43790 char *kwnames[] = {
43791 (char *) "self", NULL
43792 };
43793
43794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43796 if (SWIG_arg_fail(1)) SWIG_fail;
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 result = wxGBSizerItem_GetEndPos(arg1);
43800
43801 wxPyEndAllowThreads(__tstate);
43802 if (PyErr_Occurred()) SWIG_fail;
43803 }
43804 {
43805 wxGBPosition * resultptr;
43806 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43807 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43808 }
43809 return resultobj;
43810 fail:
43811 return NULL;
43812 }
43813
43814
43815 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43816 PyObject *resultobj = NULL;
43817 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43818 wxGridBagSizer *result;
43819 PyObject * obj0 = 0 ;
43820 char *kwnames[] = {
43821 (char *) "self", NULL
43822 };
43823
43824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43826 if (SWIG_arg_fail(1)) SWIG_fail;
43827 {
43828 PyThreadState* __tstate = wxPyBeginAllowThreads();
43829 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43830
43831 wxPyEndAllowThreads(__tstate);
43832 if (PyErr_Occurred()) SWIG_fail;
43833 }
43834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43835 return resultobj;
43836 fail:
43837 return NULL;
43838 }
43839
43840
43841 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43842 PyObject *resultobj = NULL;
43843 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43844 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43845 PyObject * obj0 = 0 ;
43846 PyObject * obj1 = 0 ;
43847 char *kwnames[] = {
43848 (char *) "self",(char *) "sizer", NULL
43849 };
43850
43851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43853 if (SWIG_arg_fail(1)) SWIG_fail;
43854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43855 if (SWIG_arg_fail(2)) SWIG_fail;
43856 {
43857 PyThreadState* __tstate = wxPyBeginAllowThreads();
43858 (arg1)->SetGBSizer(arg2);
43859
43860 wxPyEndAllowThreads(__tstate);
43861 if (PyErr_Occurred()) SWIG_fail;
43862 }
43863 Py_INCREF(Py_None); resultobj = Py_None;
43864 return resultobj;
43865 fail:
43866 return NULL;
43867 }
43868
43869
43870 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43871 PyObject *obj;
43872 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43873 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43874 Py_INCREF(obj);
43875 return Py_BuildValue((char *)"");
43876 }
43877 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43878 PyObject *resultobj = NULL;
43879 int arg1 = (int) 0 ;
43880 int arg2 = (int) 0 ;
43881 wxGridBagSizer *result;
43882 PyObject * obj0 = 0 ;
43883 PyObject * obj1 = 0 ;
43884 char *kwnames[] = {
43885 (char *) "vgap",(char *) "hgap", NULL
43886 };
43887
43888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43889 if (obj0) {
43890 {
43891 arg1 = static_cast<int >(SWIG_As_int(obj0));
43892 if (SWIG_arg_fail(1)) SWIG_fail;
43893 }
43894 }
43895 if (obj1) {
43896 {
43897 arg2 = static_cast<int >(SWIG_As_int(obj1));
43898 if (SWIG_arg_fail(2)) SWIG_fail;
43899 }
43900 }
43901 {
43902 PyThreadState* __tstate = wxPyBeginAllowThreads();
43903 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43904
43905 wxPyEndAllowThreads(__tstate);
43906 if (PyErr_Occurred()) SWIG_fail;
43907 }
43908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43909 return resultobj;
43910 fail:
43911 return NULL;
43912 }
43913
43914
43915 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43916 PyObject *resultobj = NULL;
43917 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43918 PyObject *arg2 = (PyObject *) 0 ;
43919 wxGBPosition *arg3 = 0 ;
43920 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43921 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43922 int arg5 = (int) 0 ;
43923 int arg6 = (int) 0 ;
43924 PyObject *arg7 = (PyObject *) NULL ;
43925 wxGBSizerItem *result;
43926 wxGBPosition temp3 ;
43927 wxGBSpan temp4 ;
43928 PyObject * obj0 = 0 ;
43929 PyObject * obj1 = 0 ;
43930 PyObject * obj2 = 0 ;
43931 PyObject * obj3 = 0 ;
43932 PyObject * obj4 = 0 ;
43933 PyObject * obj5 = 0 ;
43934 PyObject * obj6 = 0 ;
43935 char *kwnames[] = {
43936 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43937 };
43938
43939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43941 if (SWIG_arg_fail(1)) SWIG_fail;
43942 arg2 = obj1;
43943 {
43944 arg3 = &temp3;
43945 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43946 }
43947 if (obj3) {
43948 {
43949 arg4 = &temp4;
43950 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43951 }
43952 }
43953 if (obj4) {
43954 {
43955 arg5 = static_cast<int >(SWIG_As_int(obj4));
43956 if (SWIG_arg_fail(5)) SWIG_fail;
43957 }
43958 }
43959 if (obj5) {
43960 {
43961 arg6 = static_cast<int >(SWIG_As_int(obj5));
43962 if (SWIG_arg_fail(6)) SWIG_fail;
43963 }
43964 }
43965 if (obj6) {
43966 arg7 = obj6;
43967 }
43968 {
43969 PyThreadState* __tstate = wxPyBeginAllowThreads();
43970 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43971
43972 wxPyEndAllowThreads(__tstate);
43973 if (PyErr_Occurred()) SWIG_fail;
43974 }
43975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43976 return resultobj;
43977 fail:
43978 return NULL;
43979 }
43980
43981
43982 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43983 PyObject *resultobj = NULL;
43984 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43985 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43986 wxGBSizerItem *result;
43987 PyObject * obj0 = 0 ;
43988 PyObject * obj1 = 0 ;
43989 char *kwnames[] = {
43990 (char *) "self",(char *) "item", NULL
43991 };
43992
43993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43995 if (SWIG_arg_fail(1)) SWIG_fail;
43996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
43997 if (SWIG_arg_fail(2)) SWIG_fail;
43998 {
43999 PyThreadState* __tstate = wxPyBeginAllowThreads();
44000 result = (wxGBSizerItem *)(arg1)->Add(arg2);
44001
44002 wxPyEndAllowThreads(__tstate);
44003 if (PyErr_Occurred()) SWIG_fail;
44004 }
44005 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44006 return resultobj;
44007 fail:
44008 return NULL;
44009 }
44010
44011
44012 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44013 PyObject *resultobj = NULL;
44014 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44015 int arg2 ;
44016 int arg3 ;
44017 wxSize result;
44018 PyObject * obj0 = 0 ;
44019 PyObject * obj1 = 0 ;
44020 PyObject * obj2 = 0 ;
44021 char *kwnames[] = {
44022 (char *) "self",(char *) "row",(char *) "col", NULL
44023 };
44024
44025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
44026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44027 if (SWIG_arg_fail(1)) SWIG_fail;
44028 {
44029 arg2 = static_cast<int >(SWIG_As_int(obj1));
44030 if (SWIG_arg_fail(2)) SWIG_fail;
44031 }
44032 {
44033 arg3 = static_cast<int >(SWIG_As_int(obj2));
44034 if (SWIG_arg_fail(3)) SWIG_fail;
44035 }
44036 {
44037 PyThreadState* __tstate = wxPyBeginAllowThreads();
44038 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
44039
44040 wxPyEndAllowThreads(__tstate);
44041 if (PyErr_Occurred()) SWIG_fail;
44042 }
44043 {
44044 wxSize * resultptr;
44045 resultptr = new wxSize(static_cast<wxSize & >(result));
44046 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44047 }
44048 return resultobj;
44049 fail:
44050 return NULL;
44051 }
44052
44053
44054 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44055 PyObject *resultobj = NULL;
44056 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44057 wxSize result;
44058 PyObject * obj0 = 0 ;
44059 char *kwnames[] = {
44060 (char *) "self", NULL
44061 };
44062
44063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
44064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44065 if (SWIG_arg_fail(1)) SWIG_fail;
44066 {
44067 PyThreadState* __tstate = wxPyBeginAllowThreads();
44068 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
44069
44070 wxPyEndAllowThreads(__tstate);
44071 if (PyErr_Occurred()) SWIG_fail;
44072 }
44073 {
44074 wxSize * resultptr;
44075 resultptr = new wxSize(static_cast<wxSize & >(result));
44076 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44077 }
44078 return resultobj;
44079 fail:
44080 return NULL;
44081 }
44082
44083
44084 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44085 PyObject *resultobj = NULL;
44086 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44087 wxSize *arg2 = 0 ;
44088 wxSize temp2 ;
44089 PyObject * obj0 = 0 ;
44090 PyObject * obj1 = 0 ;
44091 char *kwnames[] = {
44092 (char *) "self",(char *) "sz", NULL
44093 };
44094
44095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
44096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44097 if (SWIG_arg_fail(1)) SWIG_fail;
44098 {
44099 arg2 = &temp2;
44100 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44101 }
44102 {
44103 PyThreadState* __tstate = wxPyBeginAllowThreads();
44104 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
44105
44106 wxPyEndAllowThreads(__tstate);
44107 if (PyErr_Occurred()) SWIG_fail;
44108 }
44109 Py_INCREF(Py_None); resultobj = Py_None;
44110 return resultobj;
44111 fail:
44112 return NULL;
44113 }
44114
44115
44116 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44117 PyObject *resultobj = NULL;
44118 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44119 wxWindow *arg2 = (wxWindow *) 0 ;
44120 wxGBPosition result;
44121 PyObject * obj0 = 0 ;
44122 PyObject * obj1 = 0 ;
44123
44124 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44126 if (SWIG_arg_fail(1)) SWIG_fail;
44127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44128 if (SWIG_arg_fail(2)) SWIG_fail;
44129 {
44130 PyThreadState* __tstate = wxPyBeginAllowThreads();
44131 result = (arg1)->GetItemPosition(arg2);
44132
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 {
44137 wxGBPosition * resultptr;
44138 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44139 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44140 }
44141 return resultobj;
44142 fail:
44143 return NULL;
44144 }
44145
44146
44147 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44148 PyObject *resultobj = NULL;
44149 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44150 wxSizer *arg2 = (wxSizer *) 0 ;
44151 wxGBPosition result;
44152 PyObject * obj0 = 0 ;
44153 PyObject * obj1 = 0 ;
44154
44155 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44157 if (SWIG_arg_fail(1)) SWIG_fail;
44158 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44159 if (SWIG_arg_fail(2)) SWIG_fail;
44160 {
44161 PyThreadState* __tstate = wxPyBeginAllowThreads();
44162 result = (arg1)->GetItemPosition(arg2);
44163
44164 wxPyEndAllowThreads(__tstate);
44165 if (PyErr_Occurred()) SWIG_fail;
44166 }
44167 {
44168 wxGBPosition * resultptr;
44169 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44170 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44171 }
44172 return resultobj;
44173 fail:
44174 return NULL;
44175 }
44176
44177
44178 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44179 PyObject *resultobj = NULL;
44180 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44181 size_t arg2 ;
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 {
44190 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44191 if (SWIG_arg_fail(2)) SWIG_fail;
44192 }
44193 {
44194 PyThreadState* __tstate = wxPyBeginAllowThreads();
44195 result = (arg1)->GetItemPosition(arg2);
44196
44197 wxPyEndAllowThreads(__tstate);
44198 if (PyErr_Occurred()) SWIG_fail;
44199 }
44200 {
44201 wxGBPosition * resultptr;
44202 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44203 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44204 }
44205 return resultobj;
44206 fail:
44207 return NULL;
44208 }
44209
44210
44211 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44212 int argc;
44213 PyObject *argv[3];
44214 int ii;
44215
44216 argc = PyObject_Length(args);
44217 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44218 argv[ii] = PyTuple_GetItem(args,ii);
44219 }
44220 if (argc == 2) {
44221 int _v;
44222 {
44223 void *ptr;
44224 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44225 _v = 0;
44226 PyErr_Clear();
44227 } else {
44228 _v = 1;
44229 }
44230 }
44231 if (_v) {
44232 {
44233 void *ptr;
44234 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44235 _v = 0;
44236 PyErr_Clear();
44237 } else {
44238 _v = 1;
44239 }
44240 }
44241 if (_v) {
44242 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44243 }
44244 }
44245 }
44246 if (argc == 2) {
44247 int _v;
44248 {
44249 void *ptr;
44250 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44251 _v = 0;
44252 PyErr_Clear();
44253 } else {
44254 _v = 1;
44255 }
44256 }
44257 if (_v) {
44258 {
44259 void *ptr;
44260 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44261 _v = 0;
44262 PyErr_Clear();
44263 } else {
44264 _v = 1;
44265 }
44266 }
44267 if (_v) {
44268 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44269 }
44270 }
44271 }
44272 if (argc == 2) {
44273 int _v;
44274 {
44275 void *ptr;
44276 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44277 _v = 0;
44278 PyErr_Clear();
44279 } else {
44280 _v = 1;
44281 }
44282 }
44283 if (_v) {
44284 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44285 if (_v) {
44286 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44287 }
44288 }
44289 }
44290
44291 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44292 return NULL;
44293 }
44294
44295
44296 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44297 PyObject *resultobj = NULL;
44298 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44299 wxWindow *arg2 = (wxWindow *) 0 ;
44300 wxGBPosition *arg3 = 0 ;
44301 bool result;
44302 wxGBPosition temp3 ;
44303 PyObject * obj0 = 0 ;
44304 PyObject * obj1 = 0 ;
44305 PyObject * obj2 = 0 ;
44306
44307 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44309 if (SWIG_arg_fail(1)) SWIG_fail;
44310 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44311 if (SWIG_arg_fail(2)) SWIG_fail;
44312 {
44313 arg3 = &temp3;
44314 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44315 }
44316 {
44317 PyThreadState* __tstate = wxPyBeginAllowThreads();
44318 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44319
44320 wxPyEndAllowThreads(__tstate);
44321 if (PyErr_Occurred()) SWIG_fail;
44322 }
44323 {
44324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44325 }
44326 return resultobj;
44327 fail:
44328 return NULL;
44329 }
44330
44331
44332 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44333 PyObject *resultobj = NULL;
44334 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44335 wxSizer *arg2 = (wxSizer *) 0 ;
44336 wxGBPosition *arg3 = 0 ;
44337 bool result;
44338 wxGBPosition temp3 ;
44339 PyObject * obj0 = 0 ;
44340 PyObject * obj1 = 0 ;
44341 PyObject * obj2 = 0 ;
44342
44343 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44345 if (SWIG_arg_fail(1)) SWIG_fail;
44346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44347 if (SWIG_arg_fail(2)) SWIG_fail;
44348 {
44349 arg3 = &temp3;
44350 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44351 }
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44355
44356 wxPyEndAllowThreads(__tstate);
44357 if (PyErr_Occurred()) SWIG_fail;
44358 }
44359 {
44360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44361 }
44362 return resultobj;
44363 fail:
44364 return NULL;
44365 }
44366
44367
44368 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44369 PyObject *resultobj = NULL;
44370 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44371 size_t arg2 ;
44372 wxGBPosition *arg3 = 0 ;
44373 bool result;
44374 wxGBPosition temp3 ;
44375 PyObject * obj0 = 0 ;
44376 PyObject * obj1 = 0 ;
44377 PyObject * obj2 = 0 ;
44378
44379 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44381 if (SWIG_arg_fail(1)) SWIG_fail;
44382 {
44383 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44384 if (SWIG_arg_fail(2)) SWIG_fail;
44385 }
44386 {
44387 arg3 = &temp3;
44388 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44389 }
44390 {
44391 PyThreadState* __tstate = wxPyBeginAllowThreads();
44392 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44393
44394 wxPyEndAllowThreads(__tstate);
44395 if (PyErr_Occurred()) SWIG_fail;
44396 }
44397 {
44398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44399 }
44400 return resultobj;
44401 fail:
44402 return NULL;
44403 }
44404
44405
44406 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44407 int argc;
44408 PyObject *argv[4];
44409 int ii;
44410
44411 argc = PyObject_Length(args);
44412 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44413 argv[ii] = PyTuple_GetItem(args,ii);
44414 }
44415 if (argc == 3) {
44416 int _v;
44417 {
44418 void *ptr;
44419 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44420 _v = 0;
44421 PyErr_Clear();
44422 } else {
44423 _v = 1;
44424 }
44425 }
44426 if (_v) {
44427 {
44428 void *ptr;
44429 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44430 _v = 0;
44431 PyErr_Clear();
44432 } else {
44433 _v = 1;
44434 }
44435 }
44436 if (_v) {
44437 {
44438 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44439 }
44440 if (_v) {
44441 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44442 }
44443 }
44444 }
44445 }
44446 if (argc == 3) {
44447 int _v;
44448 {
44449 void *ptr;
44450 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44451 _v = 0;
44452 PyErr_Clear();
44453 } else {
44454 _v = 1;
44455 }
44456 }
44457 if (_v) {
44458 {
44459 void *ptr;
44460 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44461 _v = 0;
44462 PyErr_Clear();
44463 } else {
44464 _v = 1;
44465 }
44466 }
44467 if (_v) {
44468 {
44469 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44470 }
44471 if (_v) {
44472 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44473 }
44474 }
44475 }
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 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44490 if (_v) {
44491 {
44492 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44493 }
44494 if (_v) {
44495 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44496 }
44497 }
44498 }
44499 }
44500
44501 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44502 return NULL;
44503 }
44504
44505
44506 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44507 PyObject *resultobj = NULL;
44508 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44509 wxWindow *arg2 = (wxWindow *) 0 ;
44510 wxGBSpan result;
44511 PyObject * obj0 = 0 ;
44512 PyObject * obj1 = 0 ;
44513
44514 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44516 if (SWIG_arg_fail(1)) SWIG_fail;
44517 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44518 if (SWIG_arg_fail(2)) SWIG_fail;
44519 {
44520 PyThreadState* __tstate = wxPyBeginAllowThreads();
44521 result = (arg1)->GetItemSpan(arg2);
44522
44523 wxPyEndAllowThreads(__tstate);
44524 if (PyErr_Occurred()) SWIG_fail;
44525 }
44526 {
44527 wxGBSpan * resultptr;
44528 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44530 }
44531 return resultobj;
44532 fail:
44533 return NULL;
44534 }
44535
44536
44537 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44538 PyObject *resultobj = NULL;
44539 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44540 wxSizer *arg2 = (wxSizer *) 0 ;
44541 wxGBSpan result;
44542 PyObject * obj0 = 0 ;
44543 PyObject * obj1 = 0 ;
44544
44545 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44547 if (SWIG_arg_fail(1)) SWIG_fail;
44548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44549 if (SWIG_arg_fail(2)) SWIG_fail;
44550 {
44551 PyThreadState* __tstate = wxPyBeginAllowThreads();
44552 result = (arg1)->GetItemSpan(arg2);
44553
44554 wxPyEndAllowThreads(__tstate);
44555 if (PyErr_Occurred()) SWIG_fail;
44556 }
44557 {
44558 wxGBSpan * resultptr;
44559 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44561 }
44562 return resultobj;
44563 fail:
44564 return NULL;
44565 }
44566
44567
44568 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44569 PyObject *resultobj = NULL;
44570 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44571 size_t arg2 ;
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 {
44580 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44581 if (SWIG_arg_fail(2)) SWIG_fail;
44582 }
44583 {
44584 PyThreadState* __tstate = wxPyBeginAllowThreads();
44585 result = (arg1)->GetItemSpan(arg2);
44586
44587 wxPyEndAllowThreads(__tstate);
44588 if (PyErr_Occurred()) SWIG_fail;
44589 }
44590 {
44591 wxGBSpan * resultptr;
44592 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44593 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44594 }
44595 return resultobj;
44596 fail:
44597 return NULL;
44598 }
44599
44600
44601 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44602 int argc;
44603 PyObject *argv[3];
44604 int ii;
44605
44606 argc = PyObject_Length(args);
44607 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44608 argv[ii] = PyTuple_GetItem(args,ii);
44609 }
44610 if (argc == 2) {
44611 int _v;
44612 {
44613 void *ptr;
44614 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44615 _v = 0;
44616 PyErr_Clear();
44617 } else {
44618 _v = 1;
44619 }
44620 }
44621 if (_v) {
44622 {
44623 void *ptr;
44624 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44625 _v = 0;
44626 PyErr_Clear();
44627 } else {
44628 _v = 1;
44629 }
44630 }
44631 if (_v) {
44632 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44633 }
44634 }
44635 }
44636 if (argc == 2) {
44637 int _v;
44638 {
44639 void *ptr;
44640 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44641 _v = 0;
44642 PyErr_Clear();
44643 } else {
44644 _v = 1;
44645 }
44646 }
44647 if (_v) {
44648 {
44649 void *ptr;
44650 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44651 _v = 0;
44652 PyErr_Clear();
44653 } else {
44654 _v = 1;
44655 }
44656 }
44657 if (_v) {
44658 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44659 }
44660 }
44661 }
44662 if (argc == 2) {
44663 int _v;
44664 {
44665 void *ptr;
44666 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44667 _v = 0;
44668 PyErr_Clear();
44669 } else {
44670 _v = 1;
44671 }
44672 }
44673 if (_v) {
44674 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44675 if (_v) {
44676 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44677 }
44678 }
44679 }
44680
44681 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44682 return NULL;
44683 }
44684
44685
44686 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44687 PyObject *resultobj = NULL;
44688 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44689 wxWindow *arg2 = (wxWindow *) 0 ;
44690 wxGBSpan *arg3 = 0 ;
44691 bool result;
44692 wxGBSpan temp3 ;
44693 PyObject * obj0 = 0 ;
44694 PyObject * obj1 = 0 ;
44695 PyObject * obj2 = 0 ;
44696
44697 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44699 if (SWIG_arg_fail(1)) SWIG_fail;
44700 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44701 if (SWIG_arg_fail(2)) SWIG_fail;
44702 {
44703 arg3 = &temp3;
44704 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44705 }
44706 {
44707 PyThreadState* __tstate = wxPyBeginAllowThreads();
44708 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44709
44710 wxPyEndAllowThreads(__tstate);
44711 if (PyErr_Occurred()) SWIG_fail;
44712 }
44713 {
44714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44715 }
44716 return resultobj;
44717 fail:
44718 return NULL;
44719 }
44720
44721
44722 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44723 PyObject *resultobj = NULL;
44724 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44725 wxSizer *arg2 = (wxSizer *) 0 ;
44726 wxGBSpan *arg3 = 0 ;
44727 bool result;
44728 wxGBSpan temp3 ;
44729 PyObject * obj0 = 0 ;
44730 PyObject * obj1 = 0 ;
44731 PyObject * obj2 = 0 ;
44732
44733 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44735 if (SWIG_arg_fail(1)) SWIG_fail;
44736 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44737 if (SWIG_arg_fail(2)) SWIG_fail;
44738 {
44739 arg3 = &temp3;
44740 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44741 }
44742 {
44743 PyThreadState* __tstate = wxPyBeginAllowThreads();
44744 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44745
44746 wxPyEndAllowThreads(__tstate);
44747 if (PyErr_Occurred()) SWIG_fail;
44748 }
44749 {
44750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44751 }
44752 return resultobj;
44753 fail:
44754 return NULL;
44755 }
44756
44757
44758 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44759 PyObject *resultobj = NULL;
44760 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44761 size_t arg2 ;
44762 wxGBSpan *arg3 = 0 ;
44763 bool result;
44764 wxGBSpan temp3 ;
44765 PyObject * obj0 = 0 ;
44766 PyObject * obj1 = 0 ;
44767 PyObject * obj2 = 0 ;
44768
44769 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44771 if (SWIG_arg_fail(1)) SWIG_fail;
44772 {
44773 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44774 if (SWIG_arg_fail(2)) SWIG_fail;
44775 }
44776 {
44777 arg3 = &temp3;
44778 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44779 }
44780 {
44781 PyThreadState* __tstate = wxPyBeginAllowThreads();
44782 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44783
44784 wxPyEndAllowThreads(__tstate);
44785 if (PyErr_Occurred()) SWIG_fail;
44786 }
44787 {
44788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44789 }
44790 return resultobj;
44791 fail:
44792 return NULL;
44793 }
44794
44795
44796 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44797 int argc;
44798 PyObject *argv[4];
44799 int ii;
44800
44801 argc = PyObject_Length(args);
44802 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44803 argv[ii] = PyTuple_GetItem(args,ii);
44804 }
44805 if (argc == 3) {
44806 int _v;
44807 {
44808 void *ptr;
44809 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44810 _v = 0;
44811 PyErr_Clear();
44812 } else {
44813 _v = 1;
44814 }
44815 }
44816 if (_v) {
44817 {
44818 void *ptr;
44819 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44820 _v = 0;
44821 PyErr_Clear();
44822 } else {
44823 _v = 1;
44824 }
44825 }
44826 if (_v) {
44827 {
44828 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44829 }
44830 if (_v) {
44831 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44832 }
44833 }
44834 }
44835 }
44836 if (argc == 3) {
44837 int _v;
44838 {
44839 void *ptr;
44840 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44841 _v = 0;
44842 PyErr_Clear();
44843 } else {
44844 _v = 1;
44845 }
44846 }
44847 if (_v) {
44848 {
44849 void *ptr;
44850 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44851 _v = 0;
44852 PyErr_Clear();
44853 } else {
44854 _v = 1;
44855 }
44856 }
44857 if (_v) {
44858 {
44859 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44860 }
44861 if (_v) {
44862 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44863 }
44864 }
44865 }
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 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44880 if (_v) {
44881 {
44882 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44883 }
44884 if (_v) {
44885 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44886 }
44887 }
44888 }
44889 }
44890
44891 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44892 return NULL;
44893 }
44894
44895
44896 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44897 PyObject *resultobj = NULL;
44898 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44899 wxWindow *arg2 = (wxWindow *) 0 ;
44900 wxGBSizerItem *result;
44901 PyObject * obj0 = 0 ;
44902 PyObject * obj1 = 0 ;
44903
44904 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44906 if (SWIG_arg_fail(1)) SWIG_fail;
44907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44908 if (SWIG_arg_fail(2)) SWIG_fail;
44909 {
44910 PyThreadState* __tstate = wxPyBeginAllowThreads();
44911 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44912
44913 wxPyEndAllowThreads(__tstate);
44914 if (PyErr_Occurred()) SWIG_fail;
44915 }
44916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44917 return resultobj;
44918 fail:
44919 return NULL;
44920 }
44921
44922
44923 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44924 PyObject *resultobj = NULL;
44925 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44926 wxSizer *arg2 = (wxSizer *) 0 ;
44927 wxGBSizerItem *result;
44928 PyObject * obj0 = 0 ;
44929 PyObject * obj1 = 0 ;
44930
44931 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44933 if (SWIG_arg_fail(1)) SWIG_fail;
44934 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44935 if (SWIG_arg_fail(2)) SWIG_fail;
44936 {
44937 PyThreadState* __tstate = wxPyBeginAllowThreads();
44938 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44939
44940 wxPyEndAllowThreads(__tstate);
44941 if (PyErr_Occurred()) SWIG_fail;
44942 }
44943 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44944 return resultobj;
44945 fail:
44946 return NULL;
44947 }
44948
44949
44950 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44951 int argc;
44952 PyObject *argv[3];
44953 int ii;
44954
44955 argc = PyObject_Length(args);
44956 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44957 argv[ii] = PyTuple_GetItem(args,ii);
44958 }
44959 if (argc == 2) {
44960 int _v;
44961 {
44962 void *ptr;
44963 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44964 _v = 0;
44965 PyErr_Clear();
44966 } else {
44967 _v = 1;
44968 }
44969 }
44970 if (_v) {
44971 {
44972 void *ptr;
44973 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44974 _v = 0;
44975 PyErr_Clear();
44976 } else {
44977 _v = 1;
44978 }
44979 }
44980 if (_v) {
44981 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44982 }
44983 }
44984 }
44985 if (argc == 2) {
44986 int _v;
44987 {
44988 void *ptr;
44989 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44990 _v = 0;
44991 PyErr_Clear();
44992 } else {
44993 _v = 1;
44994 }
44995 }
44996 if (_v) {
44997 {
44998 void *ptr;
44999 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
45000 _v = 0;
45001 PyErr_Clear();
45002 } else {
45003 _v = 1;
45004 }
45005 }
45006 if (_v) {
45007 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
45008 }
45009 }
45010 }
45011
45012 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
45013 return NULL;
45014 }
45015
45016
45017 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
45018 PyObject *resultobj = NULL;
45019 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45020 wxGBPosition *arg2 = 0 ;
45021 wxGBSizerItem *result;
45022 wxGBPosition temp2 ;
45023 PyObject * obj0 = 0 ;
45024 PyObject * obj1 = 0 ;
45025 char *kwnames[] = {
45026 (char *) "self",(char *) "pos", NULL
45027 };
45028
45029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
45030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45031 if (SWIG_arg_fail(1)) SWIG_fail;
45032 {
45033 arg2 = &temp2;
45034 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45035 }
45036 {
45037 PyThreadState* __tstate = wxPyBeginAllowThreads();
45038 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
45039
45040 wxPyEndAllowThreads(__tstate);
45041 if (PyErr_Occurred()) SWIG_fail;
45042 }
45043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45044 return resultobj;
45045 fail:
45046 return NULL;
45047 }
45048
45049
45050 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
45051 PyObject *resultobj = NULL;
45052 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45053 wxPoint *arg2 = 0 ;
45054 wxGBSizerItem *result;
45055 wxPoint temp2 ;
45056 PyObject * obj0 = 0 ;
45057 PyObject * obj1 = 0 ;
45058 char *kwnames[] = {
45059 (char *) "self",(char *) "pt", NULL
45060 };
45061
45062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
45063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45064 if (SWIG_arg_fail(1)) SWIG_fail;
45065 {
45066 arg2 = &temp2;
45067 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45068 }
45069 {
45070 PyThreadState* __tstate = wxPyBeginAllowThreads();
45071 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
45072
45073 wxPyEndAllowThreads(__tstate);
45074 if (PyErr_Occurred()) SWIG_fail;
45075 }
45076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45077 return resultobj;
45078 fail:
45079 return NULL;
45080 }
45081
45082
45083 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
45084 PyObject *resultobj = NULL;
45085 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45086 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
45087 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
45088 bool result;
45089 PyObject * obj0 = 0 ;
45090 PyObject * obj1 = 0 ;
45091 PyObject * obj2 = 0 ;
45092 char *kwnames[] = {
45093 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
45094 };
45095
45096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
45097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45098 if (SWIG_arg_fail(1)) SWIG_fail;
45099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45100 if (SWIG_arg_fail(2)) SWIG_fail;
45101 if (obj2) {
45102 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45103 if (SWIG_arg_fail(3)) SWIG_fail;
45104 }
45105 {
45106 PyThreadState* __tstate = wxPyBeginAllowThreads();
45107 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
45108
45109 wxPyEndAllowThreads(__tstate);
45110 if (PyErr_Occurred()) SWIG_fail;
45111 }
45112 {
45113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45114 }
45115 return resultobj;
45116 fail:
45117 return NULL;
45118 }
45119
45120
45121 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
45122 PyObject *resultobj = NULL;
45123 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45124 wxGBPosition *arg2 = 0 ;
45125 wxGBSpan *arg3 = 0 ;
45126 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45127 bool result;
45128 wxGBPosition temp2 ;
45129 wxGBSpan temp3 ;
45130 PyObject * obj0 = 0 ;
45131 PyObject * obj1 = 0 ;
45132 PyObject * obj2 = 0 ;
45133 PyObject * obj3 = 0 ;
45134 char *kwnames[] = {
45135 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45136 };
45137
45138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45140 if (SWIG_arg_fail(1)) SWIG_fail;
45141 {
45142 arg2 = &temp2;
45143 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45144 }
45145 {
45146 arg3 = &temp3;
45147 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45148 }
45149 if (obj3) {
45150 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45151 if (SWIG_arg_fail(4)) SWIG_fail;
45152 }
45153 {
45154 PyThreadState* __tstate = wxPyBeginAllowThreads();
45155 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45156
45157 wxPyEndAllowThreads(__tstate);
45158 if (PyErr_Occurred()) SWIG_fail;
45159 }
45160 {
45161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45162 }
45163 return resultobj;
45164 fail:
45165 return NULL;
45166 }
45167
45168
45169 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45170 PyObject *obj;
45171 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45172 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45173 Py_INCREF(obj);
45174 return Py_BuildValue((char *)"");
45175 }
45176 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45177 PyObject *resultobj = NULL;
45178 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45179 wxRelationship arg2 ;
45180 wxWindow *arg3 = (wxWindow *) 0 ;
45181 wxEdge arg4 ;
45182 int arg5 = (int) 0 ;
45183 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45184 PyObject * obj0 = 0 ;
45185 PyObject * obj1 = 0 ;
45186 PyObject * obj2 = 0 ;
45187 PyObject * obj3 = 0 ;
45188 PyObject * obj4 = 0 ;
45189 PyObject * obj5 = 0 ;
45190 char *kwnames[] = {
45191 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45192 };
45193
45194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45196 if (SWIG_arg_fail(1)) SWIG_fail;
45197 {
45198 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45199 if (SWIG_arg_fail(2)) SWIG_fail;
45200 }
45201 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45202 if (SWIG_arg_fail(3)) SWIG_fail;
45203 {
45204 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45205 if (SWIG_arg_fail(4)) SWIG_fail;
45206 }
45207 if (obj4) {
45208 {
45209 arg5 = static_cast<int >(SWIG_As_int(obj4));
45210 if (SWIG_arg_fail(5)) SWIG_fail;
45211 }
45212 }
45213 if (obj5) {
45214 {
45215 arg6 = static_cast<int >(SWIG_As_int(obj5));
45216 if (SWIG_arg_fail(6)) SWIG_fail;
45217 }
45218 }
45219 {
45220 PyThreadState* __tstate = wxPyBeginAllowThreads();
45221 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45222
45223 wxPyEndAllowThreads(__tstate);
45224 if (PyErr_Occurred()) SWIG_fail;
45225 }
45226 Py_INCREF(Py_None); resultobj = Py_None;
45227 return resultobj;
45228 fail:
45229 return NULL;
45230 }
45231
45232
45233 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45234 PyObject *resultobj = NULL;
45235 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45236 wxWindow *arg2 = (wxWindow *) 0 ;
45237 int arg3 = (int) 0 ;
45238 PyObject * obj0 = 0 ;
45239 PyObject * obj1 = 0 ;
45240 PyObject * obj2 = 0 ;
45241 char *kwnames[] = {
45242 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45243 };
45244
45245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45247 if (SWIG_arg_fail(1)) SWIG_fail;
45248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45249 if (SWIG_arg_fail(2)) SWIG_fail;
45250 if (obj2) {
45251 {
45252 arg3 = static_cast<int >(SWIG_As_int(obj2));
45253 if (SWIG_arg_fail(3)) SWIG_fail;
45254 }
45255 }
45256 {
45257 PyThreadState* __tstate = wxPyBeginAllowThreads();
45258 (arg1)->LeftOf(arg2,arg3);
45259
45260 wxPyEndAllowThreads(__tstate);
45261 if (PyErr_Occurred()) SWIG_fail;
45262 }
45263 Py_INCREF(Py_None); resultobj = Py_None;
45264 return resultobj;
45265 fail:
45266 return NULL;
45267 }
45268
45269
45270 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45271 PyObject *resultobj = NULL;
45272 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45273 wxWindow *arg2 = (wxWindow *) 0 ;
45274 int arg3 = (int) 0 ;
45275 PyObject * obj0 = 0 ;
45276 PyObject * obj1 = 0 ;
45277 PyObject * obj2 = 0 ;
45278 char *kwnames[] = {
45279 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45280 };
45281
45282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45284 if (SWIG_arg_fail(1)) SWIG_fail;
45285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45286 if (SWIG_arg_fail(2)) SWIG_fail;
45287 if (obj2) {
45288 {
45289 arg3 = static_cast<int >(SWIG_As_int(obj2));
45290 if (SWIG_arg_fail(3)) SWIG_fail;
45291 }
45292 }
45293 {
45294 PyThreadState* __tstate = wxPyBeginAllowThreads();
45295 (arg1)->RightOf(arg2,arg3);
45296
45297 wxPyEndAllowThreads(__tstate);
45298 if (PyErr_Occurred()) SWIG_fail;
45299 }
45300 Py_INCREF(Py_None); resultobj = Py_None;
45301 return resultobj;
45302 fail:
45303 return NULL;
45304 }
45305
45306
45307 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45308 PyObject *resultobj = NULL;
45309 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45310 wxWindow *arg2 = (wxWindow *) 0 ;
45311 int arg3 = (int) 0 ;
45312 PyObject * obj0 = 0 ;
45313 PyObject * obj1 = 0 ;
45314 PyObject * obj2 = 0 ;
45315 char *kwnames[] = {
45316 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45317 };
45318
45319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45321 if (SWIG_arg_fail(1)) SWIG_fail;
45322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45323 if (SWIG_arg_fail(2)) SWIG_fail;
45324 if (obj2) {
45325 {
45326 arg3 = static_cast<int >(SWIG_As_int(obj2));
45327 if (SWIG_arg_fail(3)) SWIG_fail;
45328 }
45329 }
45330 {
45331 PyThreadState* __tstate = wxPyBeginAllowThreads();
45332 (arg1)->Above(arg2,arg3);
45333
45334 wxPyEndAllowThreads(__tstate);
45335 if (PyErr_Occurred()) SWIG_fail;
45336 }
45337 Py_INCREF(Py_None); resultobj = Py_None;
45338 return resultobj;
45339 fail:
45340 return NULL;
45341 }
45342
45343
45344 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45345 PyObject *resultobj = NULL;
45346 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45347 wxWindow *arg2 = (wxWindow *) 0 ;
45348 int arg3 = (int) 0 ;
45349 PyObject * obj0 = 0 ;
45350 PyObject * obj1 = 0 ;
45351 PyObject * obj2 = 0 ;
45352 char *kwnames[] = {
45353 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45354 };
45355
45356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45358 if (SWIG_arg_fail(1)) SWIG_fail;
45359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45360 if (SWIG_arg_fail(2)) SWIG_fail;
45361 if (obj2) {
45362 {
45363 arg3 = static_cast<int >(SWIG_As_int(obj2));
45364 if (SWIG_arg_fail(3)) SWIG_fail;
45365 }
45366 }
45367 {
45368 PyThreadState* __tstate = wxPyBeginAllowThreads();
45369 (arg1)->Below(arg2,arg3);
45370
45371 wxPyEndAllowThreads(__tstate);
45372 if (PyErr_Occurred()) SWIG_fail;
45373 }
45374 Py_INCREF(Py_None); resultobj = Py_None;
45375 return resultobj;
45376 fail:
45377 return NULL;
45378 }
45379
45380
45381 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45382 PyObject *resultobj = NULL;
45383 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45384 wxWindow *arg2 = (wxWindow *) 0 ;
45385 wxEdge arg3 ;
45386 int arg4 = (int) 0 ;
45387 PyObject * obj0 = 0 ;
45388 PyObject * obj1 = 0 ;
45389 PyObject * obj2 = 0 ;
45390 PyObject * obj3 = 0 ;
45391 char *kwnames[] = {
45392 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45393 };
45394
45395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45397 if (SWIG_arg_fail(1)) SWIG_fail;
45398 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45399 if (SWIG_arg_fail(2)) SWIG_fail;
45400 {
45401 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45402 if (SWIG_arg_fail(3)) SWIG_fail;
45403 }
45404 if (obj3) {
45405 {
45406 arg4 = static_cast<int >(SWIG_As_int(obj3));
45407 if (SWIG_arg_fail(4)) SWIG_fail;
45408 }
45409 }
45410 {
45411 PyThreadState* __tstate = wxPyBeginAllowThreads();
45412 (arg1)->SameAs(arg2,arg3,arg4);
45413
45414 wxPyEndAllowThreads(__tstate);
45415 if (PyErr_Occurred()) SWIG_fail;
45416 }
45417 Py_INCREF(Py_None); resultobj = Py_None;
45418 return resultobj;
45419 fail:
45420 return NULL;
45421 }
45422
45423
45424 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45425 PyObject *resultobj = NULL;
45426 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45427 wxWindow *arg2 = (wxWindow *) 0 ;
45428 wxEdge arg3 ;
45429 int arg4 ;
45430 PyObject * obj0 = 0 ;
45431 PyObject * obj1 = 0 ;
45432 PyObject * obj2 = 0 ;
45433 PyObject * obj3 = 0 ;
45434 char *kwnames[] = {
45435 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45436 };
45437
45438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45440 if (SWIG_arg_fail(1)) SWIG_fail;
45441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45442 if (SWIG_arg_fail(2)) SWIG_fail;
45443 {
45444 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45445 if (SWIG_arg_fail(3)) SWIG_fail;
45446 }
45447 {
45448 arg4 = static_cast<int >(SWIG_As_int(obj3));
45449 if (SWIG_arg_fail(4)) SWIG_fail;
45450 }
45451 {
45452 PyThreadState* __tstate = wxPyBeginAllowThreads();
45453 (arg1)->PercentOf(arg2,arg3,arg4);
45454
45455 wxPyEndAllowThreads(__tstate);
45456 if (PyErr_Occurred()) SWIG_fail;
45457 }
45458 Py_INCREF(Py_None); resultobj = Py_None;
45459 return resultobj;
45460 fail:
45461 return NULL;
45462 }
45463
45464
45465 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45466 PyObject *resultobj = NULL;
45467 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45468 int arg2 ;
45469 PyObject * obj0 = 0 ;
45470 PyObject * obj1 = 0 ;
45471 char *kwnames[] = {
45472 (char *) "self",(char *) "val", NULL
45473 };
45474
45475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45477 if (SWIG_arg_fail(1)) SWIG_fail;
45478 {
45479 arg2 = static_cast<int >(SWIG_As_int(obj1));
45480 if (SWIG_arg_fail(2)) SWIG_fail;
45481 }
45482 {
45483 PyThreadState* __tstate = wxPyBeginAllowThreads();
45484 (arg1)->Absolute(arg2);
45485
45486 wxPyEndAllowThreads(__tstate);
45487 if (PyErr_Occurred()) SWIG_fail;
45488 }
45489 Py_INCREF(Py_None); resultobj = Py_None;
45490 return resultobj;
45491 fail:
45492 return NULL;
45493 }
45494
45495
45496 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45497 PyObject *resultobj = NULL;
45498 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45499 PyObject * obj0 = 0 ;
45500 char *kwnames[] = {
45501 (char *) "self", NULL
45502 };
45503
45504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45506 if (SWIG_arg_fail(1)) SWIG_fail;
45507 {
45508 PyThreadState* __tstate = wxPyBeginAllowThreads();
45509 (arg1)->Unconstrained();
45510
45511 wxPyEndAllowThreads(__tstate);
45512 if (PyErr_Occurred()) SWIG_fail;
45513 }
45514 Py_INCREF(Py_None); resultobj = Py_None;
45515 return resultobj;
45516 fail:
45517 return NULL;
45518 }
45519
45520
45521 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45522 PyObject *resultobj = NULL;
45523 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45524 PyObject * obj0 = 0 ;
45525 char *kwnames[] = {
45526 (char *) "self", NULL
45527 };
45528
45529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45531 if (SWIG_arg_fail(1)) SWIG_fail;
45532 {
45533 PyThreadState* __tstate = wxPyBeginAllowThreads();
45534 (arg1)->AsIs();
45535
45536 wxPyEndAllowThreads(__tstate);
45537 if (PyErr_Occurred()) SWIG_fail;
45538 }
45539 Py_INCREF(Py_None); resultobj = Py_None;
45540 return resultobj;
45541 fail:
45542 return NULL;
45543 }
45544
45545
45546 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45547 PyObject *resultobj = NULL;
45548 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45549 wxWindow *result;
45550 PyObject * obj0 = 0 ;
45551 char *kwnames[] = {
45552 (char *) "self", NULL
45553 };
45554
45555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45557 if (SWIG_arg_fail(1)) SWIG_fail;
45558 {
45559 PyThreadState* __tstate = wxPyBeginAllowThreads();
45560 result = (wxWindow *)(arg1)->GetOtherWindow();
45561
45562 wxPyEndAllowThreads(__tstate);
45563 if (PyErr_Occurred()) SWIG_fail;
45564 }
45565 {
45566 resultobj = wxPyMake_wxObject(result, 0);
45567 }
45568 return resultobj;
45569 fail:
45570 return NULL;
45571 }
45572
45573
45574 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45575 PyObject *resultobj = NULL;
45576 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45577 wxEdge result;
45578 PyObject * obj0 = 0 ;
45579 char *kwnames[] = {
45580 (char *) "self", NULL
45581 };
45582
45583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45585 if (SWIG_arg_fail(1)) SWIG_fail;
45586 {
45587 PyThreadState* __tstate = wxPyBeginAllowThreads();
45588 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45589
45590 wxPyEndAllowThreads(__tstate);
45591 if (PyErr_Occurred()) SWIG_fail;
45592 }
45593 resultobj = SWIG_From_int((result));
45594 return resultobj;
45595 fail:
45596 return NULL;
45597 }
45598
45599
45600 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45601 PyObject *resultobj = NULL;
45602 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45603 wxEdge arg2 ;
45604 PyObject * obj0 = 0 ;
45605 PyObject * obj1 = 0 ;
45606 char *kwnames[] = {
45607 (char *) "self",(char *) "which", NULL
45608 };
45609
45610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45612 if (SWIG_arg_fail(1)) SWIG_fail;
45613 {
45614 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45615 if (SWIG_arg_fail(2)) SWIG_fail;
45616 }
45617 {
45618 PyThreadState* __tstate = wxPyBeginAllowThreads();
45619 (arg1)->SetEdge(arg2);
45620
45621 wxPyEndAllowThreads(__tstate);
45622 if (PyErr_Occurred()) SWIG_fail;
45623 }
45624 Py_INCREF(Py_None); resultobj = Py_None;
45625 return resultobj;
45626 fail:
45627 return NULL;
45628 }
45629
45630
45631 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45632 PyObject *resultobj = NULL;
45633 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45634 int arg2 ;
45635 PyObject * obj0 = 0 ;
45636 PyObject * obj1 = 0 ;
45637 char *kwnames[] = {
45638 (char *) "self",(char *) "v", NULL
45639 };
45640
45641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45643 if (SWIG_arg_fail(1)) SWIG_fail;
45644 {
45645 arg2 = static_cast<int >(SWIG_As_int(obj1));
45646 if (SWIG_arg_fail(2)) SWIG_fail;
45647 }
45648 {
45649 PyThreadState* __tstate = wxPyBeginAllowThreads();
45650 (arg1)->SetValue(arg2);
45651
45652 wxPyEndAllowThreads(__tstate);
45653 if (PyErr_Occurred()) SWIG_fail;
45654 }
45655 Py_INCREF(Py_None); resultobj = Py_None;
45656 return resultobj;
45657 fail:
45658 return NULL;
45659 }
45660
45661
45662 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45663 PyObject *resultobj = NULL;
45664 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45665 int result;
45666 PyObject * obj0 = 0 ;
45667 char *kwnames[] = {
45668 (char *) "self", NULL
45669 };
45670
45671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45673 if (SWIG_arg_fail(1)) SWIG_fail;
45674 {
45675 PyThreadState* __tstate = wxPyBeginAllowThreads();
45676 result = (int)(arg1)->GetMargin();
45677
45678 wxPyEndAllowThreads(__tstate);
45679 if (PyErr_Occurred()) SWIG_fail;
45680 }
45681 {
45682 resultobj = SWIG_From_int(static_cast<int >(result));
45683 }
45684 return resultobj;
45685 fail:
45686 return NULL;
45687 }
45688
45689
45690 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45691 PyObject *resultobj = NULL;
45692 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45693 int arg2 ;
45694 PyObject * obj0 = 0 ;
45695 PyObject * obj1 = 0 ;
45696 char *kwnames[] = {
45697 (char *) "self",(char *) "m", NULL
45698 };
45699
45700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45702 if (SWIG_arg_fail(1)) SWIG_fail;
45703 {
45704 arg2 = static_cast<int >(SWIG_As_int(obj1));
45705 if (SWIG_arg_fail(2)) SWIG_fail;
45706 }
45707 {
45708 PyThreadState* __tstate = wxPyBeginAllowThreads();
45709 (arg1)->SetMargin(arg2);
45710
45711 wxPyEndAllowThreads(__tstate);
45712 if (PyErr_Occurred()) SWIG_fail;
45713 }
45714 Py_INCREF(Py_None); resultobj = Py_None;
45715 return resultobj;
45716 fail:
45717 return NULL;
45718 }
45719
45720
45721 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45722 PyObject *resultobj = NULL;
45723 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45724 int result;
45725 PyObject * obj0 = 0 ;
45726 char *kwnames[] = {
45727 (char *) "self", NULL
45728 };
45729
45730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45732 if (SWIG_arg_fail(1)) SWIG_fail;
45733 {
45734 PyThreadState* __tstate = wxPyBeginAllowThreads();
45735 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45736
45737 wxPyEndAllowThreads(__tstate);
45738 if (PyErr_Occurred()) SWIG_fail;
45739 }
45740 {
45741 resultobj = SWIG_From_int(static_cast<int >(result));
45742 }
45743 return resultobj;
45744 fail:
45745 return NULL;
45746 }
45747
45748
45749 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45750 PyObject *resultobj = NULL;
45751 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45752 int result;
45753 PyObject * obj0 = 0 ;
45754 char *kwnames[] = {
45755 (char *) "self", NULL
45756 };
45757
45758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45760 if (SWIG_arg_fail(1)) SWIG_fail;
45761 {
45762 PyThreadState* __tstate = wxPyBeginAllowThreads();
45763 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45764
45765 wxPyEndAllowThreads(__tstate);
45766 if (PyErr_Occurred()) SWIG_fail;
45767 }
45768 {
45769 resultobj = SWIG_From_int(static_cast<int >(result));
45770 }
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45778 PyObject *resultobj = NULL;
45779 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45780 int result;
45781 PyObject * obj0 = 0 ;
45782 char *kwnames[] = {
45783 (char *) "self", NULL
45784 };
45785
45786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45788 if (SWIG_arg_fail(1)) SWIG_fail;
45789 {
45790 PyThreadState* __tstate = wxPyBeginAllowThreads();
45791 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45792
45793 wxPyEndAllowThreads(__tstate);
45794 if (PyErr_Occurred()) SWIG_fail;
45795 }
45796 {
45797 resultobj = SWIG_From_int(static_cast<int >(result));
45798 }
45799 return resultobj;
45800 fail:
45801 return NULL;
45802 }
45803
45804
45805 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45806 PyObject *resultobj = NULL;
45807 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45808 bool result;
45809 PyObject * obj0 = 0 ;
45810 char *kwnames[] = {
45811 (char *) "self", NULL
45812 };
45813
45814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45816 if (SWIG_arg_fail(1)) SWIG_fail;
45817 {
45818 PyThreadState* __tstate = wxPyBeginAllowThreads();
45819 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45820
45821 wxPyEndAllowThreads(__tstate);
45822 if (PyErr_Occurred()) SWIG_fail;
45823 }
45824 {
45825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45826 }
45827 return resultobj;
45828 fail:
45829 return NULL;
45830 }
45831
45832
45833 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45834 PyObject *resultobj = NULL;
45835 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45836 bool arg2 ;
45837 PyObject * obj0 = 0 ;
45838 PyObject * obj1 = 0 ;
45839 char *kwnames[] = {
45840 (char *) "self",(char *) "d", NULL
45841 };
45842
45843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45845 if (SWIG_arg_fail(1)) SWIG_fail;
45846 {
45847 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45848 if (SWIG_arg_fail(2)) SWIG_fail;
45849 }
45850 {
45851 PyThreadState* __tstate = wxPyBeginAllowThreads();
45852 (arg1)->SetDone(arg2);
45853
45854 wxPyEndAllowThreads(__tstate);
45855 if (PyErr_Occurred()) SWIG_fail;
45856 }
45857 Py_INCREF(Py_None); resultobj = Py_None;
45858 return resultobj;
45859 fail:
45860 return NULL;
45861 }
45862
45863
45864 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45865 PyObject *resultobj = NULL;
45866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45867 wxRelationship result;
45868 PyObject * obj0 = 0 ;
45869 char *kwnames[] = {
45870 (char *) "self", NULL
45871 };
45872
45873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45875 if (SWIG_arg_fail(1)) SWIG_fail;
45876 {
45877 PyThreadState* __tstate = wxPyBeginAllowThreads();
45878 result = (wxRelationship)(arg1)->GetRelationship();
45879
45880 wxPyEndAllowThreads(__tstate);
45881 if (PyErr_Occurred()) SWIG_fail;
45882 }
45883 resultobj = SWIG_From_int((result));
45884 return resultobj;
45885 fail:
45886 return NULL;
45887 }
45888
45889
45890 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45891 PyObject *resultobj = NULL;
45892 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45893 wxRelationship arg2 ;
45894 PyObject * obj0 = 0 ;
45895 PyObject * obj1 = 0 ;
45896 char *kwnames[] = {
45897 (char *) "self",(char *) "r", NULL
45898 };
45899
45900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45902 if (SWIG_arg_fail(1)) SWIG_fail;
45903 {
45904 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45905 if (SWIG_arg_fail(2)) SWIG_fail;
45906 }
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 (arg1)->SetRelationship(arg2);
45910
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 Py_INCREF(Py_None); resultobj = Py_None;
45915 return resultobj;
45916 fail:
45917 return NULL;
45918 }
45919
45920
45921 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45922 PyObject *resultobj = NULL;
45923 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45924 wxWindow *arg2 = (wxWindow *) 0 ;
45925 bool result;
45926 PyObject * obj0 = 0 ;
45927 PyObject * obj1 = 0 ;
45928 char *kwnames[] = {
45929 (char *) "self",(char *) "otherW", NULL
45930 };
45931
45932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45934 if (SWIG_arg_fail(1)) SWIG_fail;
45935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45936 if (SWIG_arg_fail(2)) SWIG_fail;
45937 {
45938 PyThreadState* __tstate = wxPyBeginAllowThreads();
45939 result = (bool)(arg1)->ResetIfWin(arg2);
45940
45941 wxPyEndAllowThreads(__tstate);
45942 if (PyErr_Occurred()) SWIG_fail;
45943 }
45944 {
45945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45946 }
45947 return resultobj;
45948 fail:
45949 return NULL;
45950 }
45951
45952
45953 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45954 PyObject *resultobj = NULL;
45955 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45956 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45957 wxWindow *arg3 = (wxWindow *) 0 ;
45958 bool result;
45959 PyObject * obj0 = 0 ;
45960 PyObject * obj1 = 0 ;
45961 PyObject * obj2 = 0 ;
45962 char *kwnames[] = {
45963 (char *) "self",(char *) "constraints",(char *) "win", NULL
45964 };
45965
45966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45968 if (SWIG_arg_fail(1)) SWIG_fail;
45969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45970 if (SWIG_arg_fail(2)) SWIG_fail;
45971 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45972 if (SWIG_arg_fail(3)) SWIG_fail;
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45976
45977 wxPyEndAllowThreads(__tstate);
45978 if (PyErr_Occurred()) SWIG_fail;
45979 }
45980 {
45981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45982 }
45983 return resultobj;
45984 fail:
45985 return NULL;
45986 }
45987
45988
45989 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45990 PyObject *resultobj = NULL;
45991 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45992 wxEdge arg2 ;
45993 wxWindow *arg3 = (wxWindow *) 0 ;
45994 wxWindow *arg4 = (wxWindow *) 0 ;
45995 int result;
45996 PyObject * obj0 = 0 ;
45997 PyObject * obj1 = 0 ;
45998 PyObject * obj2 = 0 ;
45999 PyObject * obj3 = 0 ;
46000 char *kwnames[] = {
46001 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
46002 };
46003
46004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
46005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46006 if (SWIG_arg_fail(1)) SWIG_fail;
46007 {
46008 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
46009 if (SWIG_arg_fail(2)) SWIG_fail;
46010 }
46011 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46012 if (SWIG_arg_fail(3)) SWIG_fail;
46013 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46014 if (SWIG_arg_fail(4)) SWIG_fail;
46015 {
46016 PyThreadState* __tstate = wxPyBeginAllowThreads();
46017 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
46018
46019 wxPyEndAllowThreads(__tstate);
46020 if (PyErr_Occurred()) SWIG_fail;
46021 }
46022 {
46023 resultobj = SWIG_From_int(static_cast<int >(result));
46024 }
46025 return resultobj;
46026 fail:
46027 return NULL;
46028 }
46029
46030
46031 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
46032 PyObject *obj;
46033 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46034 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
46035 Py_INCREF(obj);
46036 return Py_BuildValue((char *)"");
46037 }
46038 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
46039 PyObject *resultobj = NULL;
46040 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46041 wxIndividualLayoutConstraint *result;
46042 PyObject * obj0 = 0 ;
46043 char *kwnames[] = {
46044 (char *) "self", NULL
46045 };
46046
46047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
46048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46049 if (SWIG_arg_fail(1)) SWIG_fail;
46050 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
46051
46052 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46053 return resultobj;
46054 fail:
46055 return NULL;
46056 }
46057
46058
46059 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
46060 PyObject *resultobj = NULL;
46061 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46062 wxIndividualLayoutConstraint *result;
46063 PyObject * obj0 = 0 ;
46064 char *kwnames[] = {
46065 (char *) "self", NULL
46066 };
46067
46068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
46069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46070 if (SWIG_arg_fail(1)) SWIG_fail;
46071 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
46072
46073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46074 return resultobj;
46075 fail:
46076 return NULL;
46077 }
46078
46079
46080 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
46081 PyObject *resultobj = NULL;
46082 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46083 wxIndividualLayoutConstraint *result;
46084 PyObject * obj0 = 0 ;
46085 char *kwnames[] = {
46086 (char *) "self", NULL
46087 };
46088
46089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
46090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46091 if (SWIG_arg_fail(1)) SWIG_fail;
46092 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
46093
46094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46095 return resultobj;
46096 fail:
46097 return NULL;
46098 }
46099
46100
46101 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
46102 PyObject *resultobj = NULL;
46103 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46104 wxIndividualLayoutConstraint *result;
46105 PyObject * obj0 = 0 ;
46106 char *kwnames[] = {
46107 (char *) "self", NULL
46108 };
46109
46110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
46111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46112 if (SWIG_arg_fail(1)) SWIG_fail;
46113 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
46114
46115 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46116 return resultobj;
46117 fail:
46118 return NULL;
46119 }
46120
46121
46122 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
46123 PyObject *resultobj = NULL;
46124 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46125 wxIndividualLayoutConstraint *result;
46126 PyObject * obj0 = 0 ;
46127 char *kwnames[] = {
46128 (char *) "self", NULL
46129 };
46130
46131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46133 if (SWIG_arg_fail(1)) SWIG_fail;
46134 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46135
46136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46137 return resultobj;
46138 fail:
46139 return NULL;
46140 }
46141
46142
46143 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46144 PyObject *resultobj = NULL;
46145 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46146 wxIndividualLayoutConstraint *result;
46147 PyObject * obj0 = 0 ;
46148 char *kwnames[] = {
46149 (char *) "self", NULL
46150 };
46151
46152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46154 if (SWIG_arg_fail(1)) SWIG_fail;
46155 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46156
46157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46158 return resultobj;
46159 fail:
46160 return NULL;
46161 }
46162
46163
46164 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
46165 PyObject *resultobj = NULL;
46166 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46167 wxIndividualLayoutConstraint *result;
46168 PyObject * obj0 = 0 ;
46169 char *kwnames[] = {
46170 (char *) "self", NULL
46171 };
46172
46173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
46174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46175 if (SWIG_arg_fail(1)) SWIG_fail;
46176 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
46177
46178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46179 return resultobj;
46180 fail:
46181 return NULL;
46182 }
46183
46184
46185 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
46186 PyObject *resultobj = NULL;
46187 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46188 wxIndividualLayoutConstraint *result;
46189 PyObject * obj0 = 0 ;
46190 char *kwnames[] = {
46191 (char *) "self", NULL
46192 };
46193
46194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
46195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46196 if (SWIG_arg_fail(1)) SWIG_fail;
46197 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
46198
46199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46200 return resultobj;
46201 fail:
46202 return NULL;
46203 }
46204
46205
46206 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46207 PyObject *resultobj = NULL;
46208 wxLayoutConstraints *result;
46209 char *kwnames[] = {
46210 NULL
46211 };
46212
46213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46214 {
46215 PyThreadState* __tstate = wxPyBeginAllowThreads();
46216 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46217
46218 wxPyEndAllowThreads(__tstate);
46219 if (PyErr_Occurred()) SWIG_fail;
46220 }
46221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46222 return resultobj;
46223 fail:
46224 return NULL;
46225 }
46226
46227
46228 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46229 PyObject *resultobj = NULL;
46230 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46231 wxWindow *arg2 = (wxWindow *) 0 ;
46232 int *arg3 = (int *) 0 ;
46233 bool result;
46234 int temp3 ;
46235 int res3 = 0 ;
46236 PyObject * obj0 = 0 ;
46237 PyObject * obj1 = 0 ;
46238 char *kwnames[] = {
46239 (char *) "self",(char *) "win", NULL
46240 };
46241
46242 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46245 if (SWIG_arg_fail(1)) SWIG_fail;
46246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46247 if (SWIG_arg_fail(2)) SWIG_fail;
46248 {
46249 PyThreadState* __tstate = wxPyBeginAllowThreads();
46250 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46251
46252 wxPyEndAllowThreads(__tstate);
46253 if (PyErr_Occurred()) SWIG_fail;
46254 }
46255 {
46256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46257 }
46258 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46259 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46260 return resultobj;
46261 fail:
46262 return NULL;
46263 }
46264
46265
46266 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46267 PyObject *resultobj = NULL;
46268 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46269 bool result;
46270 PyObject * obj0 = 0 ;
46271 char *kwnames[] = {
46272 (char *) "self", NULL
46273 };
46274
46275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46277 if (SWIG_arg_fail(1)) SWIG_fail;
46278 {
46279 PyThreadState* __tstate = wxPyBeginAllowThreads();
46280 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46281
46282 wxPyEndAllowThreads(__tstate);
46283 if (PyErr_Occurred()) SWIG_fail;
46284 }
46285 {
46286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46287 }
46288 return resultobj;
46289 fail:
46290 return NULL;
46291 }
46292
46293
46294 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46295 PyObject *obj;
46296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46297 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46298 Py_INCREF(obj);
46299 return Py_BuildValue((char *)"");
46300 }
46301 static PyMethodDef SwigMethods[] = {
46302 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46303 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46304 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46307 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46328 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46341 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46356 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46410 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46438 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46457 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46459 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46467 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46468 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46480 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46492 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46496 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46502 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46512 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46522 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46525 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46532 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46540 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46548 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46632 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46634 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46636 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46638 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46640 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46642 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46644 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46646 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46648 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46650 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46652 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46654 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46656 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46670 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46688 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46691 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46694 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46706 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46711 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46717 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46723 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46786 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46793 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46829 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46839 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46845 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46847 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46849 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46852 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46856 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46859 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46862 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46864 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46869 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46877 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46881 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46884 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46886 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46890 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46907 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46909 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46912 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46914 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46918 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46922 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46933 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46936 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46939 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46943 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46950 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46955 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46960 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46964 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
47009 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
47029 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
47032 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
47039 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
47043 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
47053 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47224 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47265 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47280 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47283 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47285 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47287 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47314 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47338 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47351 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47367 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47369 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47372 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47381 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47383 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47384 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47386 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47388 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47390 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47391 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47392 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47393 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47401 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47402 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47403 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47405 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47407 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47408 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47409 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47410 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47411 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47412 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47413 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47415 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47419 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47421 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47422 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47425 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47427 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47431 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47432 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47434 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47435 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47437 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47438 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47439 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47440 { (char *)"delete_SizerItem", (PyCFunction) _wrap_delete_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47441 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47445 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47446 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47447 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47456 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47459 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47460 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47461 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47463 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47465 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47466 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47467 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47468 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47469 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47470 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47471 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47472 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47475 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47477 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47478 { (char *)"delete_Sizer", (PyCFunction) _wrap_delete_Sizer, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47480 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47483 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47487 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47488 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47489 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47490 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47491 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47492 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47494 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47496 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47499 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47502 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47503 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47504 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47509 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47511 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47512 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47514 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47515 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47516 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47517 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47518 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47519 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47520 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47521 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47522 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47523 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47524 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47525 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47526 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47527 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47528 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47529 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47530 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47531 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47532 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47533 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47534 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47535 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47536 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47537 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47538 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47539 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47540 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47541 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47542 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47543 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47544 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47545 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47546 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47547 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47548 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47549 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47550 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47551 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47552 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47553 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47554 { (char *)"delete_GBPosition", (PyCFunction) _wrap_delete_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47555 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47556 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47557 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47558 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47559 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47560 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47561 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47562 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47563 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47564 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47565 { (char *)"delete_GBSpan", (PyCFunction) _wrap_delete_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47566 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47567 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47568 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47569 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47570 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47571 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47572 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47573 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47574 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47575 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47576 { (char *)"delete_GBSizerItem", (PyCFunction) _wrap_delete_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47577 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47578 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47579 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47580 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47581 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47582 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47583 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47584 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47585 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47586 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47587 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47588 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47589 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47590 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47591 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47592 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47593 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47594 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47595 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47596 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47597 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47598 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47599 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47600 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47601 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47602 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47603 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47604 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47605 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47606 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47607 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47608 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47609 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47610 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47611 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47612 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47613 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47614 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47615 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47616 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47617 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47618 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47619 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47620 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47621 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47622 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47623 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47624 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47625 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47626 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47627 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47628 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47629 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47630 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47631 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47632 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47633 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47634 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47635 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47636 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47637 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47638 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47639 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47640 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47641 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47642 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47643 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47644 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47645 { NULL, NULL, 0, NULL }
47646 };
47647
47648
47649 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47650
47651 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47652 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47653 }
47654 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47655 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47656 }
47657 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47658 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47659 }
47660 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47661 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47662 }
47663 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47664 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47665 }
47666 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47667 return (void *)((wxSizer *) ((wxGridSizer *) x));
47668 }
47669 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47670 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47671 }
47672 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47673 return (void *)((wxSizer *) ((wxPySizer *) x));
47674 }
47675 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47676 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47677 }
47678 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47679 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47680 }
47681 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47682 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47683 }
47684 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47685 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47686 }
47687 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47688 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47689 }
47690 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47691 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47692 }
47693 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47694 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47695 }
47696 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47697 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47698 }
47699 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47700 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47701 }
47702 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47703 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47704 }
47705 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47706 return (void *)((wxEvent *) ((wxPyEvent *) x));
47707 }
47708 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47709 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47710 }
47711 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47712 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47713 }
47714 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47715 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47716 }
47717 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47718 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47719 }
47720 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47721 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47722 }
47723 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47724 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47725 }
47726 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47727 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47728 }
47729 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47730 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47731 }
47732 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47733 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47734 }
47735 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47736 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47737 }
47738 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47739 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47740 }
47741 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47742 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47743 }
47744 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47745 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47746 }
47747 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47748 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47749 }
47750 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47751 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47752 }
47753 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47754 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47755 }
47756 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47757 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47758 }
47759 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47760 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47761 }
47762 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47763 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47764 }
47765 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47766 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47767 }
47768 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47769 return (void *)((wxEvent *) ((wxShowEvent *) x));
47770 }
47771 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47772 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47773 }
47774 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47775 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47776 }
47777 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47778 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47779 }
47780 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47781 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47782 }
47783 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47784 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47785 }
47786 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47787 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47788 }
47789 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47790 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47791 }
47792 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47793 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47794 }
47795 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47796 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47797 }
47798 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47799 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47800 }
47801 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47802 return (void *)((wxControl *) ((wxControlWithItems *) x));
47803 }
47804 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47805 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47806 }
47807 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47808 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47809 }
47810 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47811 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47812 }
47813 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47814 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47815 }
47816 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47817 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47818 }
47819 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47820 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47821 }
47822 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47823 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47824 }
47825 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47826 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47827 }
47828 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47829 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47830 }
47831 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47832 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47833 }
47834 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47835 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47836 }
47837 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47838 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47839 }
47840 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47841 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47842 }
47843 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47844 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47845 }
47846 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47847 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47848 }
47849 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47850 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47851 }
47852 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47853 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47854 }
47855 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47856 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47857 }
47858 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47859 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47860 }
47861 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47862 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47863 }
47864 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47865 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47866 }
47867 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47868 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47869 }
47870 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47871 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47872 }
47873 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47874 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47875 }
47876 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47877 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47878 }
47879 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47880 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47881 }
47882 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47883 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47884 }
47885 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47886 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47887 }
47888 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47889 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47890 }
47891 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47892 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47893 }
47894 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47895 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47896 }
47897 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47898 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47899 }
47900 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47901 return (void *)((wxObject *) ((wxSizerItem *) x));
47902 }
47903 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47904 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47905 }
47906 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47907 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47908 }
47909 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47910 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47911 }
47912 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47913 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47914 }
47915 static void *_p_wxSizerTo_p_wxObject(void *x) {
47916 return (void *)((wxObject *) ((wxSizer *) x));
47917 }
47918 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47919 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47920 }
47921 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47922 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47923 }
47924 static void *_p_wxEventTo_p_wxObject(void *x) {
47925 return (void *)((wxObject *) ((wxEvent *) x));
47926 }
47927 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47928 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47929 }
47930 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47931 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47932 }
47933 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47934 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47935 }
47936 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47937 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47938 }
47939 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47940 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47941 }
47942 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47943 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47944 }
47945 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47946 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47947 }
47948 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47949 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47950 }
47951 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47952 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47953 }
47954 static void *_p_wxControlTo_p_wxObject(void *x) {
47955 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47956 }
47957 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47958 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47959 }
47960 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47961 return (void *)((wxObject *) ((wxFSFile *) x));
47962 }
47963 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47964 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47965 }
47966 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47967 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47968 }
47969 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47970 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47971 }
47972 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47973 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47974 }
47975 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47976 return (void *)((wxObject *) ((wxMenuItem *) x));
47977 }
47978 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47979 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47980 }
47981 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47982 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47983 }
47984 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47985 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47986 }
47987 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47988 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47989 }
47990 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47991 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47992 }
47993 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47994 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47995 }
47996 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47997 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47998 }
47999 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
48000 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
48001 }
48002 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
48003 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
48004 }
48005 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
48006 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
48007 }
48008 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
48009 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
48010 }
48011 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
48012 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
48013 }
48014 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
48015 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
48016 }
48017 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
48018 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
48019 }
48020 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
48021 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
48022 }
48023 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
48024 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
48025 }
48026 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
48027 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
48028 }
48029 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
48030 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
48031 }
48032 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
48033 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
48034 }
48035 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
48036 return (void *)((wxObject *) ((wxImageHandler *) x));
48037 }
48038 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
48039 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
48040 }
48041 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
48042 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
48043 }
48044 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
48045 return (void *)((wxObject *) ((wxEvtHandler *) x));
48046 }
48047 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
48048 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
48049 }
48050 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
48051 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
48052 }
48053 static void *_p_wxImageTo_p_wxObject(void *x) {
48054 return (void *)((wxObject *) ((wxImage *) x));
48055 }
48056 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
48057 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
48058 }
48059 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
48060 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48061 }
48062 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
48063 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
48064 }
48065 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
48066 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
48067 }
48068 static void *_p_wxWindowTo_p_wxObject(void *x) {
48069 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
48070 }
48071 static void *_p_wxMenuTo_p_wxObject(void *x) {
48072 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
48073 }
48074 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
48075 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
48076 }
48077 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
48078 return (void *)((wxObject *) ((wxFileSystem *) x));
48079 }
48080 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
48081 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
48082 }
48083 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
48084 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
48085 }
48086 static void *_p_wxPyAppTo_p_wxObject(void *x) {
48087 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
48088 }
48089 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
48090 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
48091 }
48092 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
48093 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
48094 }
48095 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
48096 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
48097 }
48098 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
48099 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
48100 }
48101 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
48102 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
48103 }
48104 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
48105 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
48106 }
48107 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
48108 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
48109 }
48110 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
48111 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
48112 }
48113 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
48114 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
48115 }
48116 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
48117 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
48118 }
48119 static void *_p_wxValidatorTo_p_wxObject(void *x) {
48120 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
48121 }
48122 static void *_p_wxControlTo_p_wxWindow(void *x) {
48123 return (void *)((wxWindow *) ((wxControl *) x));
48124 }
48125 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
48126 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
48127 }
48128 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
48129 return (void *)((wxWindow *) ((wxMenuBar *) x));
48130 }
48131 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48132 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48133 }
48134 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48135 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48136 }
48137 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48138 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48139 }
48140 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48141 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48142 }
48143 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48144 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48145 }
48146 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48147 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48148 }
48149 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48150 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48151 }
48152 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48153 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48154 }
48155 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48156 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48157 }
48158 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48159 return (void *)((wxValidator *) ((wxPyValidator *) x));
48160 }
48161 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48162 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48163 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48164 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48165 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48166 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48167 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48168 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48169 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48170 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48171 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48172 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48173 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48174 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48175 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48176 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48177 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48178 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48179 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48180 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48181 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48182 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48183 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48184 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48185 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48186 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48187 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48188 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48189 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48190 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48191 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48192 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48193 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48194 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48195 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48196 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48197 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48198 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48199 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48200 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48201 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48202 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48203 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48204 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48205 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48206 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48207 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48208 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48209 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48210 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48211 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48212 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48213 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48214 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48215 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48216 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48217 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48218 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48219 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48220 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48221 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48222 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48223 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48224 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48225 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48226 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48227 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48228 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48229 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48230 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48231 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48232 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48233 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48234 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48235 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48236 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48237 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48238 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48239 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48240 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48241 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48242 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48243 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48244 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48245 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48246 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48247 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48248 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48249 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48250 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48251 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48252 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48253 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48254 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48255 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48256 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48257 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48258 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48259 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48260 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48261 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48262 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48263 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48264 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48265 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48266 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48267 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48268 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48269 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48270 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48271 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48272 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48273 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48274 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48275 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48276 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48277 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48278 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48279 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48280 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48281 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48282 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48283 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48284 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48285 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48286 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48287 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48288 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48289 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48290 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48291 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48292 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48293
48294 static swig_type_info *swig_type_initial[] = {
48295 &_swigt__p_buffer,
48296 &_swigt__p_char,
48297 &_swigt__p_form_ops_t,
48298 &_swigt__p_int,
48299 &_swigt__p_long,
48300 &_swigt__p_unsigned_char,
48301 &_swigt__p_unsigned_int,
48302 &_swigt__p_unsigned_long,
48303 &_swigt__p_wxANIHandler,
48304 &_swigt__p_wxAcceleratorEntry,
48305 &_swigt__p_wxAcceleratorTable,
48306 &_swigt__p_wxActivateEvent,
48307 &_swigt__p_wxAppTraits,
48308 &_swigt__p_wxArrayString,
48309 &_swigt__p_wxBMPHandler,
48310 &_swigt__p_wxBitmap,
48311 &_swigt__p_wxBoxSizer,
48312 &_swigt__p_wxButton,
48313 &_swigt__p_wxCURHandler,
48314 &_swigt__p_wxCaret,
48315 &_swigt__p_wxChildFocusEvent,
48316 &_swigt__p_wxCloseEvent,
48317 &_swigt__p_wxColour,
48318 &_swigt__p_wxCommandEvent,
48319 &_swigt__p_wxContextMenuEvent,
48320 &_swigt__p_wxControl,
48321 &_swigt__p_wxControlWithItems,
48322 &_swigt__p_wxCursor,
48323 &_swigt__p_wxDC,
48324 &_swigt__p_wxDateEvent,
48325 &_swigt__p_wxDateTime,
48326 &_swigt__p_wxDisplayChangedEvent,
48327 &_swigt__p_wxDropFilesEvent,
48328 &_swigt__p_wxDuplexMode,
48329 &_swigt__p_wxEraseEvent,
48330 &_swigt__p_wxEvent,
48331 &_swigt__p_wxEventLoop,
48332 &_swigt__p_wxEventLoopActivator,
48333 &_swigt__p_wxEvtHandler,
48334 &_swigt__p_wxFSFile,
48335 &_swigt__p_wxFileSystem,
48336 &_swigt__p_wxFileSystemHandler,
48337 &_swigt__p_wxFlexGridSizer,
48338 &_swigt__p_wxFocusEvent,
48339 &_swigt__p_wxFont,
48340 &_swigt__p_wxFrame,
48341 &_swigt__p_wxGBPosition,
48342 &_swigt__p_wxGBSizerItem,
48343 &_swigt__p_wxGBSpan,
48344 &_swigt__p_wxGIFHandler,
48345 &_swigt__p_wxGridBagSizer,
48346 &_swigt__p_wxGridSizer,
48347 &_swigt__p_wxICOHandler,
48348 &_swigt__p_wxIconizeEvent,
48349 &_swigt__p_wxIdleEvent,
48350 &_swigt__p_wxImage,
48351 &_swigt__p_wxImageHandler,
48352 &_swigt__p_wxImageHistogram,
48353 &_swigt__p_wxImage_HSVValue,
48354 &_swigt__p_wxImage_RGBValue,
48355 &_swigt__p_wxIndividualLayoutConstraint,
48356 &_swigt__p_wxInitDialogEvent,
48357 &_swigt__p_wxInputStream,
48358 &_swigt__p_wxInternetFSHandler,
48359 &_swigt__p_wxItemContainer,
48360 &_swigt__p_wxJPEGHandler,
48361 &_swigt__p_wxKeyEvent,
48362 &_swigt__p_wxLayoutConstraints,
48363 &_swigt__p_wxMaximizeEvent,
48364 &_swigt__p_wxMemoryFSHandler,
48365 &_swigt__p_wxMenu,
48366 &_swigt__p_wxMenuBar,
48367 &_swigt__p_wxMenuBarBase,
48368 &_swigt__p_wxMenuEvent,
48369 &_swigt__p_wxMenuItem,
48370 &_swigt__p_wxMouseCaptureChangedEvent,
48371 &_swigt__p_wxMouseEvent,
48372 &_swigt__p_wxMoveEvent,
48373 &_swigt__p_wxNavigationKeyEvent,
48374 &_swigt__p_wxNcPaintEvent,
48375 &_swigt__p_wxNotifyEvent,
48376 &_swigt__p_wxObject,
48377 &_swigt__p_wxOutputStream,
48378 &_swigt__p_wxPCXHandler,
48379 &_swigt__p_wxPNGHandler,
48380 &_swigt__p_wxPNMHandler,
48381 &_swigt__p_wxPaintEvent,
48382 &_swigt__p_wxPaletteChangedEvent,
48383 &_swigt__p_wxPaperSize,
48384 &_swigt__p_wxPoint,
48385 &_swigt__p_wxPoint2D,
48386 &_swigt__p_wxPropagateOnce,
48387 &_swigt__p_wxPropagationDisabler,
48388 &_swigt__p_wxPyApp,
48389 &_swigt__p_wxPyCommandEvent,
48390 &_swigt__p_wxPyDropTarget,
48391 &_swigt__p_wxPyEvent,
48392 &_swigt__p_wxPyFileSystemHandler,
48393 &_swigt__p_wxPyImageHandler,
48394 &_swigt__p_wxPyInputStream,
48395 &_swigt__p_wxPySizer,
48396 &_swigt__p_wxPyValidator,
48397 &_swigt__p_wxQuantize,
48398 &_swigt__p_wxQueryNewPaletteEvent,
48399 &_swigt__p_wxRealPoint,
48400 &_swigt__p_wxRect,
48401 &_swigt__p_wxRegion,
48402 &_swigt__p_wxScrollEvent,
48403 &_swigt__p_wxScrollWinEvent,
48404 &_swigt__p_wxSetCursorEvent,
48405 &_swigt__p_wxShowEvent,
48406 &_swigt__p_wxSize,
48407 &_swigt__p_wxSizeEvent,
48408 &_swigt__p_wxSizer,
48409 &_swigt__p_wxSizerItem,
48410 &_swigt__p_wxStaticBox,
48411 &_swigt__p_wxStaticBoxSizer,
48412 &_swigt__p_wxStdDialogButtonSizer,
48413 &_swigt__p_wxSysColourChangedEvent,
48414 &_swigt__p_wxTIFFHandler,
48415 &_swigt__p_wxToolTip,
48416 &_swigt__p_wxUpdateUIEvent,
48417 &_swigt__p_wxValidator,
48418 &_swigt__p_wxVisualAttributes,
48419 &_swigt__p_wxWindow,
48420 &_swigt__p_wxWindowCreateEvent,
48421 &_swigt__p_wxWindowDestroyEvent,
48422 &_swigt__p_wxXPMHandler,
48423 &_swigt__p_wxZipFSHandler,
48424 &_swigt__ptrdiff_t,
48425 &_swigt__std__ptrdiff_t,
48426 &_swigt__unsigned_int,
48427 };
48428
48429 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48430 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48431 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48432 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48433 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48434 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48435 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48436 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48437 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48438 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48439 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48440 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48441 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48442 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48443 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}};
48444 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48445 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}};
48446 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48447 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}};
48448 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48449 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48450 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48451 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48452 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}};
48453 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48454 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}};
48455 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48456 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48457 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48458 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48459 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48460 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48461 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48462 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48463 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48464 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}};
48465 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48466 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48467 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}};
48468 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48469 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48470 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}};
48471 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}};
48472 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48473 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48474 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48475 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48476 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48477 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48478 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48479 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48480 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}};
48481 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}};
48482 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48483 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48484 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48485 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}};
48486 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48487 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48488 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48489 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48490 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48491 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48492 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48493 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}};
48494 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48495 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48496 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48497 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48498 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48499 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48500 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48501 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48502 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48503 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48504 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48505 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48506 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48507 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48508 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48509 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48510 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}};
48511 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48512 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48513 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48514 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48515 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48516 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48517 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48518 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48519 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48520 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48521 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48522 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48523 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48524 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48525 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48526 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48527 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48528 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48529 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48530 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48531 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48532 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48533 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48534 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48535 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48536 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48537 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48538 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48539 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48540 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48541 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48542 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}};
48543 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}};
48544 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48545 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48546 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48547 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48548 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48549 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48550 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48551 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}};
48552 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48553 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}};
48554 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48555 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48556 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48557 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48558 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48559 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48560 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48561
48562 static swig_cast_info *swig_cast_initial[] = {
48563 _swigc__p_buffer,
48564 _swigc__p_char,
48565 _swigc__p_form_ops_t,
48566 _swigc__p_int,
48567 _swigc__p_long,
48568 _swigc__p_unsigned_char,
48569 _swigc__p_unsigned_int,
48570 _swigc__p_unsigned_long,
48571 _swigc__p_wxANIHandler,
48572 _swigc__p_wxAcceleratorEntry,
48573 _swigc__p_wxAcceleratorTable,
48574 _swigc__p_wxActivateEvent,
48575 _swigc__p_wxAppTraits,
48576 _swigc__p_wxArrayString,
48577 _swigc__p_wxBMPHandler,
48578 _swigc__p_wxBitmap,
48579 _swigc__p_wxBoxSizer,
48580 _swigc__p_wxButton,
48581 _swigc__p_wxCURHandler,
48582 _swigc__p_wxCaret,
48583 _swigc__p_wxChildFocusEvent,
48584 _swigc__p_wxCloseEvent,
48585 _swigc__p_wxColour,
48586 _swigc__p_wxCommandEvent,
48587 _swigc__p_wxContextMenuEvent,
48588 _swigc__p_wxControl,
48589 _swigc__p_wxControlWithItems,
48590 _swigc__p_wxCursor,
48591 _swigc__p_wxDC,
48592 _swigc__p_wxDateEvent,
48593 _swigc__p_wxDateTime,
48594 _swigc__p_wxDisplayChangedEvent,
48595 _swigc__p_wxDropFilesEvent,
48596 _swigc__p_wxDuplexMode,
48597 _swigc__p_wxEraseEvent,
48598 _swigc__p_wxEvent,
48599 _swigc__p_wxEventLoop,
48600 _swigc__p_wxEventLoopActivator,
48601 _swigc__p_wxEvtHandler,
48602 _swigc__p_wxFSFile,
48603 _swigc__p_wxFileSystem,
48604 _swigc__p_wxFileSystemHandler,
48605 _swigc__p_wxFlexGridSizer,
48606 _swigc__p_wxFocusEvent,
48607 _swigc__p_wxFont,
48608 _swigc__p_wxFrame,
48609 _swigc__p_wxGBPosition,
48610 _swigc__p_wxGBSizerItem,
48611 _swigc__p_wxGBSpan,
48612 _swigc__p_wxGIFHandler,
48613 _swigc__p_wxGridBagSizer,
48614 _swigc__p_wxGridSizer,
48615 _swigc__p_wxICOHandler,
48616 _swigc__p_wxIconizeEvent,
48617 _swigc__p_wxIdleEvent,
48618 _swigc__p_wxImage,
48619 _swigc__p_wxImageHandler,
48620 _swigc__p_wxImageHistogram,
48621 _swigc__p_wxImage_HSVValue,
48622 _swigc__p_wxImage_RGBValue,
48623 _swigc__p_wxIndividualLayoutConstraint,
48624 _swigc__p_wxInitDialogEvent,
48625 _swigc__p_wxInputStream,
48626 _swigc__p_wxInternetFSHandler,
48627 _swigc__p_wxItemContainer,
48628 _swigc__p_wxJPEGHandler,
48629 _swigc__p_wxKeyEvent,
48630 _swigc__p_wxLayoutConstraints,
48631 _swigc__p_wxMaximizeEvent,
48632 _swigc__p_wxMemoryFSHandler,
48633 _swigc__p_wxMenu,
48634 _swigc__p_wxMenuBar,
48635 _swigc__p_wxMenuBarBase,
48636 _swigc__p_wxMenuEvent,
48637 _swigc__p_wxMenuItem,
48638 _swigc__p_wxMouseCaptureChangedEvent,
48639 _swigc__p_wxMouseEvent,
48640 _swigc__p_wxMoveEvent,
48641 _swigc__p_wxNavigationKeyEvent,
48642 _swigc__p_wxNcPaintEvent,
48643 _swigc__p_wxNotifyEvent,
48644 _swigc__p_wxObject,
48645 _swigc__p_wxOutputStream,
48646 _swigc__p_wxPCXHandler,
48647 _swigc__p_wxPNGHandler,
48648 _swigc__p_wxPNMHandler,
48649 _swigc__p_wxPaintEvent,
48650 _swigc__p_wxPaletteChangedEvent,
48651 _swigc__p_wxPaperSize,
48652 _swigc__p_wxPoint,
48653 _swigc__p_wxPoint2D,
48654 _swigc__p_wxPropagateOnce,
48655 _swigc__p_wxPropagationDisabler,
48656 _swigc__p_wxPyApp,
48657 _swigc__p_wxPyCommandEvent,
48658 _swigc__p_wxPyDropTarget,
48659 _swigc__p_wxPyEvent,
48660 _swigc__p_wxPyFileSystemHandler,
48661 _swigc__p_wxPyImageHandler,
48662 _swigc__p_wxPyInputStream,
48663 _swigc__p_wxPySizer,
48664 _swigc__p_wxPyValidator,
48665 _swigc__p_wxQuantize,
48666 _swigc__p_wxQueryNewPaletteEvent,
48667 _swigc__p_wxRealPoint,
48668 _swigc__p_wxRect,
48669 _swigc__p_wxRegion,
48670 _swigc__p_wxScrollEvent,
48671 _swigc__p_wxScrollWinEvent,
48672 _swigc__p_wxSetCursorEvent,
48673 _swigc__p_wxShowEvent,
48674 _swigc__p_wxSize,
48675 _swigc__p_wxSizeEvent,
48676 _swigc__p_wxSizer,
48677 _swigc__p_wxSizerItem,
48678 _swigc__p_wxStaticBox,
48679 _swigc__p_wxStaticBoxSizer,
48680 _swigc__p_wxStdDialogButtonSizer,
48681 _swigc__p_wxSysColourChangedEvent,
48682 _swigc__p_wxTIFFHandler,
48683 _swigc__p_wxToolTip,
48684 _swigc__p_wxUpdateUIEvent,
48685 _swigc__p_wxValidator,
48686 _swigc__p_wxVisualAttributes,
48687 _swigc__p_wxWindow,
48688 _swigc__p_wxWindowCreateEvent,
48689 _swigc__p_wxWindowDestroyEvent,
48690 _swigc__p_wxXPMHandler,
48691 _swigc__p_wxZipFSHandler,
48692 _swigc__ptrdiff_t,
48693 _swigc__std__ptrdiff_t,
48694 _swigc__unsigned_int,
48695 };
48696
48697
48698 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48699
48700 static swig_const_info swig_const_table[] = {
48701 {0, 0, 0, 0.0, 0, 0}};
48702
48703 #ifdef __cplusplus
48704 }
48705 #endif
48706 /*************************************************************************
48707 * Type initialization:
48708 * This problem is tough by the requirement that no dynamic
48709 * memory is used. Also, since swig_type_info structures store pointers to
48710 * swig_cast_info structures and swig_cast_info structures store pointers back
48711 * to swig_type_info structures, we need some lookup code at initialization.
48712 * The idea is that swig generates all the structures that are needed.
48713 * The runtime then collects these partially filled structures.
48714 * The SWIG_InitializeModule function takes these initial arrays out of
48715 * swig_module, and does all the lookup, filling in the swig_module.types
48716 * array with the correct data and linking the correct swig_cast_info
48717 * structures together.
48718
48719 * The generated swig_type_info structures are assigned staticly to an initial
48720 * array. We just loop though that array, and handle each type individually.
48721 * First we lookup if this type has been already loaded, and if so, use the
48722 * loaded structure instead of the generated one. Then we have to fill in the
48723 * cast linked list. The cast data is initially stored in something like a
48724 * two-dimensional array. Each row corresponds to a type (there are the same
48725 * number of rows as there are in the swig_type_initial array). Each entry in
48726 * a column is one of the swig_cast_info structures for that type.
48727 * The cast_initial array is actually an array of arrays, because each row has
48728 * a variable number of columns. So to actually build the cast linked list,
48729 * we find the array of casts associated with the type, and loop through it
48730 * adding the casts to the list. The one last trick we need to do is making
48731 * sure the type pointer in the swig_cast_info struct is correct.
48732
48733 * First off, we lookup the cast->type name to see if it is already loaded.
48734 * There are three cases to handle:
48735 * 1) If the cast->type has already been loaded AND the type we are adding
48736 * casting info to has not been loaded (it is in this module), THEN we
48737 * replace the cast->type pointer with the type pointer that has already
48738 * been loaded.
48739 * 2) If BOTH types (the one we are adding casting info to, and the
48740 * cast->type) are loaded, THEN the cast info has already been loaded by
48741 * the previous module so we just ignore it.
48742 * 3) Finally, if cast->type has not already been loaded, then we add that
48743 * swig_cast_info to the linked list (because the cast->type) pointer will
48744 * be correct.
48745 **/
48746
48747 #ifdef __cplusplus
48748 extern "C" {
48749 #if 0
48750 } /* c-mode */
48751 #endif
48752 #endif
48753
48754 #if 0
48755 #define SWIGRUNTIME_DEBUG
48756 #endif
48757
48758 SWIGRUNTIME void
48759 SWIG_InitializeModule(void *clientdata) {
48760 size_t i;
48761 swig_module_info *module_head;
48762 static int init_run = 0;
48763
48764 clientdata = clientdata;
48765
48766 if (init_run) return;
48767 init_run = 1;
48768
48769 /* Initialize the swig_module */
48770 swig_module.type_initial = swig_type_initial;
48771 swig_module.cast_initial = swig_cast_initial;
48772
48773 /* Try and load any already created modules */
48774 module_head = SWIG_GetModule(clientdata);
48775 if (module_head) {
48776 swig_module.next = module_head->next;
48777 module_head->next = &swig_module;
48778 } else {
48779 /* This is the first module loaded */
48780 swig_module.next = &swig_module;
48781 SWIG_SetModule(clientdata, &swig_module);
48782 }
48783
48784 /* Now work on filling in swig_module.types */
48785 #ifdef SWIGRUNTIME_DEBUG
48786 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48787 #endif
48788 for (i = 0; i < swig_module.size; ++i) {
48789 swig_type_info *type = 0;
48790 swig_type_info *ret;
48791 swig_cast_info *cast;
48792
48793 #ifdef SWIGRUNTIME_DEBUG
48794 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48795 #endif
48796
48797 /* if there is another module already loaded */
48798 if (swig_module.next != &swig_module) {
48799 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48800 }
48801 if (type) {
48802 /* Overwrite clientdata field */
48803 #ifdef SWIGRUNTIME_DEBUG
48804 printf("SWIG_InitializeModule: found type %s\n", type->name);
48805 #endif
48806 if (swig_module.type_initial[i]->clientdata) {
48807 type->clientdata = swig_module.type_initial[i]->clientdata;
48808 #ifdef SWIGRUNTIME_DEBUG
48809 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48810 #endif
48811 }
48812 } else {
48813 type = swig_module.type_initial[i];
48814 }
48815
48816 /* Insert casting types */
48817 cast = swig_module.cast_initial[i];
48818 while (cast->type) {
48819 /* Don't need to add information already in the list */
48820 ret = 0;
48821 #ifdef SWIGRUNTIME_DEBUG
48822 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48823 #endif
48824 if (swig_module.next != &swig_module) {
48825 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48826 #ifdef SWIGRUNTIME_DEBUG
48827 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48828 #endif
48829 }
48830 if (ret) {
48831 if (type == swig_module.type_initial[i]) {
48832 #ifdef SWIGRUNTIME_DEBUG
48833 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48834 #endif
48835 cast->type = ret;
48836 ret = 0;
48837 } else {
48838 /* Check for casting already in the list */
48839 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48840 #ifdef SWIGRUNTIME_DEBUG
48841 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48842 #endif
48843 if (!ocast) ret = 0;
48844 }
48845 }
48846
48847 if (!ret) {
48848 #ifdef SWIGRUNTIME_DEBUG
48849 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48850 #endif
48851 if (type->cast) {
48852 type->cast->prev = cast;
48853 cast->next = type->cast;
48854 }
48855 type->cast = cast;
48856 }
48857 cast++;
48858 }
48859 /* Set entry in modules->types array equal to the type */
48860 swig_module.types[i] = type;
48861 }
48862 swig_module.types[i] = 0;
48863
48864 #ifdef SWIGRUNTIME_DEBUG
48865 printf("**** SWIG_InitializeModule: Cast List ******\n");
48866 for (i = 0; i < swig_module.size; ++i) {
48867 int j = 0;
48868 swig_cast_info *cast = swig_module.cast_initial[i];
48869 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48870 while (cast->type) {
48871 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48872 cast++;
48873 ++j;
48874 }
48875 printf("---- Total casts: %d\n",j);
48876 }
48877 printf("**** SWIG_InitializeModule: Cast List ******\n");
48878 #endif
48879 }
48880
48881 /* This function will propagate the clientdata field of type to
48882 * any new swig_type_info structures that have been added into the list
48883 * of equivalent types. It is like calling
48884 * SWIG_TypeClientData(type, clientdata) a second time.
48885 */
48886 SWIGRUNTIME void
48887 SWIG_PropagateClientData(void) {
48888 size_t i;
48889 swig_cast_info *equiv;
48890 static int init_run = 0;
48891
48892 if (init_run) return;
48893 init_run = 1;
48894
48895 for (i = 0; i < swig_module.size; i++) {
48896 if (swig_module.types[i]->clientdata) {
48897 equiv = swig_module.types[i]->cast;
48898 while (equiv) {
48899 if (!equiv->converter) {
48900 if (equiv->type && !equiv->type->clientdata)
48901 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
48902 }
48903 equiv = equiv->next;
48904 }
48905 }
48906 }
48907 }
48908
48909 #ifdef __cplusplus
48910 #if 0
48911 {
48912 /* c-mode */
48913 #endif
48914 }
48915 #endif
48916
48917
48918
48919 #ifdef __cplusplus
48920 extern "C" {
48921 #endif
48922
48923 /* Python-specific SWIG API */
48924 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48925 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48926 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48927
48928 /* -----------------------------------------------------------------------------
48929 * global variable support code.
48930 * ----------------------------------------------------------------------------- */
48931
48932 typedef struct swig_globalvar {
48933 char *name; /* Name of global variable */
48934 PyObject *(*get_attr)(void); /* Return the current value */
48935 int (*set_attr)(PyObject *); /* Set the value */
48936 struct swig_globalvar *next;
48937 } swig_globalvar;
48938
48939 typedef struct swig_varlinkobject {
48940 PyObject_HEAD
48941 swig_globalvar *vars;
48942 } swig_varlinkobject;
48943
48944 SWIGINTERN PyObject *
48945 swig_varlink_repr(swig_varlinkobject *v) {
48946 v = v;
48947 return PyString_FromString("<Swig global variables>");
48948 }
48949
48950 SWIGINTERN int
48951 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48952 swig_globalvar *var;
48953 flags = flags;
48954 fprintf(fp,"Swig global variables { ");
48955 for (var = v->vars; var; var=var->next) {
48956 fprintf(fp,"%s", var->name);
48957 if (var->next) fprintf(fp,", ");
48958 }
48959 fprintf(fp," }\n");
48960 return 0;
48961 }
48962
48963 SWIGINTERN PyObject *
48964 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48965 swig_globalvar *var = v->vars;
48966 while (var) {
48967 if (strcmp(var->name,n) == 0) {
48968 return (*var->get_attr)();
48969 }
48970 var = var->next;
48971 }
48972 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48973 return NULL;
48974 }
48975
48976 SWIGINTERN int
48977 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48978 swig_globalvar *var = v->vars;
48979 while (var) {
48980 if (strcmp(var->name,n) == 0) {
48981 return (*var->set_attr)(p);
48982 }
48983 var = var->next;
48984 }
48985 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48986 return 1;
48987 }
48988
48989 SWIGINTERN PyTypeObject*
48990 swig_varlink_type(void) {
48991 static char varlink__doc__[] = "Swig var link object";
48992 static PyTypeObject varlink_type
48993 #if !defined(__cplusplus)
48994 ;
48995 static int type_init = 0;
48996 if (!type_init) {
48997 PyTypeObject tmp
48998 #endif
48999 = {
49000 PyObject_HEAD_INIT(&PyType_Type)
49001 0, /* Number of items in variable part (ob_size) */
49002 (char *)"swigvarlink", /* Type name (tp_name) */
49003 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
49004 0, /* Itemsize (tp_itemsize) */
49005 0, /* Deallocator (tp_dealloc) */
49006 (printfunc) swig_varlink_print, /* Print (tp_print) */
49007 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
49008 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
49009 0, /* tp_compare */
49010 (reprfunc) swig_varlink_repr, /* tp_repr */
49011 0, /* tp_as_number */
49012 0, /* tp_as_sequence */
49013 0, /* tp_as_mapping */
49014 0, /* tp_hash */
49015 0, /* tp_call */
49016 0, /* tp_str */
49017 0, /* tp_getattro */
49018 0, /* tp_setattro */
49019 0, /* tp_as_buffer */
49020 0, /* tp_flags */
49021 varlink__doc__, /* tp_doc */
49022 #if PY_VERSION_HEX >= 0x02000000
49023 0, /* tp_traverse */
49024 0, /* tp_clear */
49025 #endif
49026 #if PY_VERSION_HEX >= 0x02010000
49027 0, /* tp_richcompare */
49028 0, /* tp_weaklistoffset */
49029 #endif
49030 #if PY_VERSION_HEX >= 0x02020000
49031 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
49032 #endif
49033 #if PY_VERSION_HEX >= 0x02030000
49034 0, /* tp_del */
49035 #endif
49036 #ifdef COUNT_ALLOCS
49037 0,0,0,0 /* tp_alloc -> tp_next */
49038 #endif
49039 };
49040 #if !defined(__cplusplus)
49041 varlink_type = tmp;
49042 type_init = 1;
49043 }
49044 #endif
49045 return &varlink_type;
49046 }
49047
49048 /* Create a variable linking object for use later */
49049 SWIGINTERN PyObject *
49050 SWIG_Python_newvarlink(void) {
49051 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
49052 if (result) {
49053 result->vars = 0;
49054 }
49055 return ((PyObject*) result);
49056 }
49057
49058 SWIGINTERN void
49059 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
49060 swig_varlinkobject *v = (swig_varlinkobject *) p;
49061 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
49062 if (gv) {
49063 size_t size = strlen(name)+1;
49064 gv->name = (char *)malloc(size);
49065 if (gv->name) {
49066 strncpy(gv->name,name,size);
49067 gv->get_attr = get_attr;
49068 gv->set_attr = set_attr;
49069 gv->next = v->vars;
49070 }
49071 }
49072 v->vars = gv;
49073 }
49074
49075 /* -----------------------------------------------------------------------------
49076 * constants/methods manipulation
49077 * ----------------------------------------------------------------------------- */
49078
49079 /* Install Constants */
49080 SWIGINTERN void
49081 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
49082 PyObject *obj = 0;
49083 size_t i;
49084 for (i = 0; constants[i].type; ++i) {
49085 switch(constants[i].type) {
49086 case SWIG_PY_INT:
49087 obj = PyInt_FromLong(constants[i].lvalue);
49088 break;
49089 case SWIG_PY_FLOAT:
49090 obj = PyFloat_FromDouble(constants[i].dvalue);
49091 break;
49092 case SWIG_PY_STRING:
49093 if (constants[i].pvalue) {
49094 obj = PyString_FromString((char *) constants[i].pvalue);
49095 } else {
49096 Py_INCREF(Py_None);
49097 obj = Py_None;
49098 }
49099 break;
49100 case SWIG_PY_POINTER:
49101 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
49102 break;
49103 case SWIG_PY_BINARY:
49104 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
49105 break;
49106 default:
49107 obj = 0;
49108 break;
49109 }
49110 if (obj) {
49111 PyDict_SetItemString(d,constants[i].name,obj);
49112 Py_DECREF(obj);
49113 }
49114 }
49115 }
49116
49117 /* -----------------------------------------------------------------------------*/
49118 /* Fix SwigMethods to carry the callback ptrs when needed */
49119 /* -----------------------------------------------------------------------------*/
49120
49121 SWIGINTERN void
49122 SWIG_Python_FixMethods(PyMethodDef *methods,
49123 swig_const_info *const_table,
49124 swig_type_info **types,
49125 swig_type_info **types_initial) {
49126 size_t i;
49127 for (i = 0; methods[i].ml_name; ++i) {
49128 char *c = methods[i].ml_doc;
49129 if (c && (c = strstr(c, "swig_ptr: "))) {
49130 int j;
49131 swig_const_info *ci = 0;
49132 char *name = c + 10;
49133 for (j = 0; const_table[j].type; ++j) {
49134 if (strncmp(const_table[j].name, name,
49135 strlen(const_table[j].name)) == 0) {
49136 ci = &(const_table[j]);
49137 break;
49138 }
49139 }
49140 if (ci) {
49141 size_t shift = (ci->ptype) - types;
49142 swig_type_info *ty = types_initial[shift];
49143 size_t ldoc = (c - methods[i].ml_doc);
49144 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49145 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49146 if (ndoc) {
49147 char *buff = ndoc;
49148 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49149 if (ptr) {
49150 strncpy(buff, methods[i].ml_doc, ldoc);
49151 buff += ldoc;
49152 strncpy(buff, "swig_ptr: ", 10);
49153 buff += 10;
49154 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49155 methods[i].ml_doc = ndoc;
49156 }
49157 }
49158 }
49159 }
49160 }
49161 }
49162
49163 /* -----------------------------------------------------------------------------*
49164 * Initialize type list
49165 * -----------------------------------------------------------------------------*/
49166
49167 #ifdef __cplusplus
49168 }
49169 #endif
49170
49171 /* -----------------------------------------------------------------------------*
49172 * Partial Init method
49173 * -----------------------------------------------------------------------------*/
49174
49175 #ifdef __cplusplus
49176 extern "C"
49177 #endif
49178 SWIGEXPORT void SWIG_init(void) {
49179 static PyObject *SWIG_globals = 0;
49180 PyObject *m, *d;
49181 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49182
49183 /* Fix SwigMethods to carry the callback ptrs when needed */
49184 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49185
49186 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49187 d = PyModule_GetDict(m);
49188
49189 SWIG_InitializeModule(0);
49190 SWIG_InstallConstants(d,swig_const_table);
49191
49192
49193 #ifndef wxPyUSE_EXPORT
49194 // Make our API structure a CObject so other modules can import it
49195 // from this module.
49196 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49197 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49198 Py_XDECREF(cobj);
49199 #endif
49200
49201 {
49202 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49485 }
49486 {
49487 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49488 }
49489 {
49490 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49548 }
49549 {
49550 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49551 }
49552 {
49553 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49554 }
49555 {
49556 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49557 }
49558 {
49559 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49572 }
49573 {
49574 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49575 }
49576 {
49577 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49578 }
49579 {
49580 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49581 }
49582 {
49583 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49584 }
49585 {
49586 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49587 }
49588 {
49589 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49602 }
49603 {
49604 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49617 }
49618 {
49619 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49620 }
49621 {
49622 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49635 }
49636 {
49637 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49641 }
49642 {
49643 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49644 }
49645 {
49646 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49647 }
49648 {
49649 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49650 }
49651 {
49652 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49653 }
49654 {
49655 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49656 }
49657 {
49658 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49659 }
49660 {
49661 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49662 }
49663 {
49664 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49665 }
49666 {
49667 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49668 }
49669 {
49670 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49671 }
49672 {
49673 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49674 }
49675 {
49676 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49677 }
49678 {
49679 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49680 }
49681 {
49682 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49683 }
49684 {
49685 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49686 }
49687 {
49688 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49689 }
49690 {
49691 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49692 }
49693 {
49694 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49695 }
49696 {
49697 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49698 }
49699 {
49700 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49701 }
49702 {
49703 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49704 }
49705 {
49706 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49707 }
49708 {
49709 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49710 }
49711 {
49712 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49713 }
49714 {
49715 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49716 }
49717 {
49718 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49719 }
49720 {
49721 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49722 }
49723 {
49724 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49725 }
49726 {
49727 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49728 }
49729 {
49730 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49731 }
49732 {
49733 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49734 }
49735 {
49736 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49737 }
49738 {
49739 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49740 }
49741 {
49742 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49743 }
49744 {
49745 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49746 }
49747 {
49748 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49749 }
49750 {
49751 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49803 }
49804 {
49805 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49824 }
49825 {
49826 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
49908 }
49909 {
49910 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
49917 }
49918 {
49919 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
49920 }
49921 {
49922 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
49923 }
49924 {
49925 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
49926 }
49927 {
49928 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
49929 }
49930 {
49931 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
49932 }
49933 {
49934 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
49935 }
49936 {
49937 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
49938 }
49939 {
49940 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
49941 }
49942 {
49943 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
49944 }
49945 {
49946 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
49947 }
49948 {
49949 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
49950 }
49951 {
49952 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
49953 }
49954 {
49955 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
49956 }
49957 {
49958 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
49959 }
49960 {
49961 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
49962 }
49963 {
49964 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
49965 }
49966 {
49967 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
49968 }
49969 {
49970 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
49971 }
49972 {
49973 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
49974 }
49975 {
49976 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
49977 }
49978 {
49979 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
49980 }
49981 {
49982 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
49983 }
49984 {
49985 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
49986 }
49987 {
49988 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
49989 }
49990 {
49991 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
49992 }
49993 {
49994 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
49995 }
49996 {
49997 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
49998 }
49999 {
50000 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
50001 }
50002 {
50003 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
50004 }
50005 {
50006 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
50007 }
50008 {
50009 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
50010 }
50011 {
50012 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
50013 }
50014 {
50015 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
50016 }
50017 {
50018 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
50019 }
50020 {
50021 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
50022 }
50023 {
50024 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
50025 }
50026 {
50027 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
50028 }
50029 {
50030 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
50031 }
50032 {
50033 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
50034 }
50035 {
50036 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
50037 }
50038 {
50039 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
50040 }
50041 {
50042 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
50043 }
50044 {
50045 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
50046 }
50047 {
50048 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
50049 }
50050 {
50051 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
50052 }
50053 {
50054 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
50055 }
50056 {
50057 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
50058 }
50059 {
50060 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
50061 }
50062 {
50063 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
50064 }
50065 {
50066 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
50067 }
50068 {
50069 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
50070 }
50071 {
50072 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
50073 }
50074 {
50075 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
50076 }
50077 {
50078 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
50079 }
50080 {
50081 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
50082 }
50083 {
50084 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
50085 }
50086 {
50087 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
50088 }
50089 {
50090 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
50091 }
50092 {
50093 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
50094 }
50095 {
50096 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
50097 }
50098 {
50099 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
50100 }
50101 {
50102 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
50103 }
50104 {
50105 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
50106 }
50107 {
50108 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
50109 }
50110 {
50111 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
50112 }
50113 {
50114 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
50115 }
50116 {
50117 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
50118 }
50119 {
50120 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
50121 }
50122 {
50123 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
50124 }
50125 {
50126 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
50127 }
50128 {
50129 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
50130 }
50131 {
50132 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50133 }
50134 {
50135 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50136 }
50137 {
50138 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50139 }
50140 {
50141 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50142 }
50143 {
50144 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50145 }
50146 {
50147 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50148 }
50149 {
50150 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50151 }
50152 {
50153 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50154 }
50155 {
50156 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50157 }
50158 {
50159 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50160 }
50161 {
50162 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50163 }
50164 {
50165 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50166 }
50167 {
50168 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50169 }
50170 {
50171 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50172 }
50173 {
50174 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50175 }
50176 {
50177 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50178 }
50179 {
50180 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50181 }
50182 {
50183 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50184 }
50185 {
50186 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50187 }
50188 {
50189 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50190 }
50191 {
50192 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50193 }
50194 {
50195 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50196 }
50197 {
50198 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50199 }
50200 {
50201 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50202 }
50203 {
50204 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50205 }
50206 {
50207 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50208 }
50209 {
50210 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50211 }
50212 {
50213 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50214 }
50215 {
50216 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50217 }
50218 {
50219 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50220 }
50221 {
50222 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50223 }
50224 {
50225 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50226 }
50227 {
50228 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50229 }
50230 {
50231 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50232 }
50233 {
50234 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50235 }
50236 {
50237 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50238 }
50239 {
50240 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50241 }
50242 {
50243 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50244 }
50245 {
50246 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50247 }
50248 {
50249 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50250 }
50251 {
50252 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50253 }
50254 {
50255 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50256 }
50257 {
50258 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50259 }
50260 {
50261 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50262 }
50263 {
50264 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50265 }
50266 {
50267 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50268 }
50269 {
50270 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50271 }
50272 {
50273 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50274 }
50275 {
50276 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50277 }
50278 {
50279 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50280 }
50281 {
50282 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50283 }
50284 {
50285 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50286 }
50287 {
50288 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50289 }
50290 {
50291 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50292 }
50293 {
50294 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50295 }
50296 {
50297 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50298 }
50299 {
50300 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50301 }
50302 {
50303 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50304 }
50305 {
50306 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50307 }
50308 {
50309 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50310 }
50311 {
50312 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50313 }
50314 {
50315 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50316 }
50317 {
50318 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50319 }
50320 {
50321 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50322 }
50323 {
50324 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50325 }
50326 {
50327 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50328 }
50329 {
50330 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50331 }
50332 {
50333 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50334 }
50335 {
50336 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50337 }
50338 {
50339 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50340 }
50341 {
50342 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50343 }
50344 {
50345 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50346 }
50347 {
50348 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50349 }
50350 {
50351 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50352 }
50353 {
50354 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50355 }
50356 {
50357 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50358 }
50359 {
50360 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50361 }
50362 {
50363 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50364 }
50365 {
50366 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50367 }
50368 {
50369 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50370 }
50371 {
50372 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50373 }
50374 {
50375 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50376 }
50377 {
50378 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50379 }
50380 {
50381 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50382 }
50383 {
50384 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50385 }
50386 {
50387 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50388 }
50389 {
50390 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50391 }
50392 {
50393 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50394 }
50395 {
50396 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50397 }
50398 {
50399 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50400 }
50401 {
50402 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50403 }
50404 {
50405 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50406 }
50407 {
50408 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50409 }
50410 {
50411 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50412 }
50413 {
50414 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50415 }
50416 {
50417 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50418 }
50419 {
50420 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50421 }
50422 {
50423 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50424 }
50425 {
50426 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50427 }
50428 {
50429 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50430 }
50431 {
50432 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50433 }
50434 {
50435 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50436 }
50437 {
50438 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50439 }
50440 {
50441 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50442 }
50443 {
50444 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50445 }
50446 {
50447 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50448 }
50449 {
50450 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50451 }
50452 {
50453 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50454 }
50455 {
50456 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50457 }
50458 {
50459 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50460 }
50461 {
50462 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50463 }
50464 {
50465 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50466 }
50467 {
50468 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50469 }
50470 {
50471 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50472 }
50473 {
50474 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50475 }
50476 {
50477 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50478 }
50479 {
50480 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50481 }
50482 {
50483 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50484 }
50485 {
50486 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50487 }
50488 {
50489 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50490 }
50491 {
50492 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50493 }
50494 {
50495 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50496 }
50497 {
50498 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50499 }
50500 {
50501 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50502 }
50503 {
50504 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50505 }
50506 {
50507 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50508 }
50509 {
50510 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50511 }
50512 {
50513 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50514 }
50515 {
50516 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50517 }
50518 {
50519 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50520 }
50521 {
50522 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50523 }
50524 {
50525 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50526 }
50527 {
50528 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50529 }
50530 {
50531 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50532 }
50533 {
50534 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50535 }
50536 {
50537 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50538 }
50539 {
50540 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50541 }
50542 {
50543 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50544 }
50545 {
50546 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50547 }
50548 {
50549 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50550 }
50551 {
50552 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50553 }
50554 {
50555 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50556 }
50557 {
50558 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50559 }
50560 {
50561 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50562 }
50563 {
50564 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50565 }
50566 {
50567 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50568 }
50569 {
50570 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50571 }
50572 {
50573 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50574 }
50575 {
50576 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50577 }
50578 {
50579 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50580 }
50581 {
50582 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50583 }
50584 {
50585 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50586 }
50587 {
50588 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50589 }
50590 {
50591 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50592 }
50593 {
50594 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50595 }
50596 {
50597 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50598 }
50599 {
50600 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50601 }
50602 {
50603 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50604 }
50605 {
50606 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50607 }
50608 {
50609 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50610 }
50611 {
50612 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50613 }
50614 {
50615 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50616 }
50617 {
50618 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50619 }
50620 {
50621 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50622 }
50623 {
50624 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50625 }
50626 {
50627 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50628 }
50629 {
50630 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50631 }
50632 {
50633 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50634 }
50635 {
50636 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50637 }
50638 {
50639 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50640 }
50641 {
50642 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50643 }
50644 {
50645 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50646 }
50647 {
50648 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50649 }
50650 {
50651 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50652 }
50653 {
50654 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50655 }
50656 {
50657 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50658 }
50659 {
50660 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50661 }
50662 {
50663 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50664 }
50665 {
50666 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50667 }
50668 {
50669 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50670 }
50671 {
50672 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50673 }
50674 {
50675 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50676 }
50677 {
50678 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50679 }
50680 {
50681 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50682 }
50683 {
50684 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50685 }
50686 {
50687 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50688 }
50689 {
50690 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50691 }
50692 {
50693 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50694 }
50695 {
50696 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50697 }
50698 {
50699 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50700 }
50701 {
50702 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50703 }
50704 {
50705 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50706 }
50707 {
50708 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50709 }
50710 {
50711 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50712 }
50713 {
50714 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50715 }
50716 {
50717 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50718 }
50719 {
50720 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50721 }
50722 {
50723 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50724 }
50725 {
50726 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50727 }
50728 {
50729 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50730 }
50731 {
50732 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50733 }
50734 {
50735 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50736 }
50737 {
50738 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50739 }
50740 {
50741 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50742 }
50743 {
50744 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50745 }
50746 {
50747 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50748 }
50749 {
50750 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50751 }
50752 {
50753 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50754 }
50755 {
50756 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50757 }
50758 {
50759 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50760 }
50761 {
50762 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50763 }
50764 {
50765 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50766 }
50767 {
50768 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50769 }
50770 {
50771 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50772 }
50773 {
50774 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50775 }
50776 {
50777 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50778 }
50779 {
50780 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50781 }
50782 {
50783 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50784 }
50785 {
50786 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50787 }
50788 {
50789 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50790 }
50791 {
50792 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50793 }
50794 {
50795 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50796 }
50797 {
50798 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50799 }
50800 {
50801 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50802 }
50803 {
50804 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50805 }
50806 {
50807 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50808 }
50809 {
50810 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50811 }
50812 {
50813 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50814 }
50815 {
50816 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50817 }
50818 {
50819 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50820 }
50821 {
50822 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50823 }
50824 {
50825 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50826 }
50827 {
50828 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50829 }
50830 {
50831 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50832 }
50833 {
50834 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50835 }
50836 {
50837 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50838 }
50839 {
50840 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50841 }
50842 {
50843 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50844 }
50845 {
50846 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50847 }
50848 {
50849 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50850 }
50851 {
50852 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50853 }
50854 {
50855 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50856 }
50857 {
50858 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50859 }
50860 {
50861 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50862 }
50863 {
50864 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50865 }
50866 {
50867 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50868 }
50869 {
50870 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50871 }
50872 {
50873 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
50874 }
50875 {
50876 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
50877 }
50878 {
50879 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
50880 }
50881 {
50882 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
50883 }
50884 {
50885 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
50886 }
50887 {
50888 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
50889 }
50890 {
50891 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
50892 }
50893 {
50894 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
50895 }
50896 {
50897 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
50898 }
50899 {
50900 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
50901 }
50902 {
50903 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
50904 }
50905 {
50906 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
50907 }
50908 {
50909 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
50910 }
50911 {
50912 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
50913 }
50914 {
50915 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
50916 }
50917 {
50918 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
50919 }
50920 {
50921 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
50922 }
50923 {
50924 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
50925 }
50926 {
50927 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
50928 }
50929 {
50930 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
50931 }
50932 {
50933 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
50934 }
50935 {
50936 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
50937 }
50938 {
50939 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
50940 }
50941 {
50942 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
50943 }
50944 {
50945 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
50946 }
50947 {
50948 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
50949 }
50950 {
50951 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
50952 }
50953 {
50954 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
50955 }
50956 {
50957 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
50958 }
50959 {
50960 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
50961 }
50962 {
50963 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50964 }
50965 {
50966 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50967 }
50968 {
50969 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
50970 }
50971 {
50972 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
50973 }
50974 {
50975 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
50976 }
50977 {
50978 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
50979 }
50980 {
50981 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
50982 }
50983 {
50984 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
50985 }
50986 {
50987 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
50988 }
50989 {
50990 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
50991 }
50992 {
50993 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
50994 }
50995 {
50996 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
50997 }
50998 {
50999 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
51000 }
51001 {
51002 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
51003 }
51004 {
51005 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
51006 }
51007 {
51008 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
51009 }
51010 {
51011 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
51012 }
51013 {
51014 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
51015 }
51016 {
51017 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
51018 }
51019 {
51020 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
51021 }
51022 {
51023 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
51024 }
51025 {
51026 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
51027 }
51028 {
51029 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
51030 }
51031 {
51032 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
51033 }
51034 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
51035 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
51036 {
51037 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
51038 }
51039 {
51040 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
51041 }
51042 {
51043 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
51044 }
51045 {
51046 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
51047 }
51048 {
51049 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
51050 }
51051 {
51052 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
51053 }
51054 {
51055 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
51056 }
51057 {
51058 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
51059 }
51060 {
51061 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
51062 }
51063 {
51064 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
51065 }
51066 {
51067 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
51068 }
51069 {
51070 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
51071 }
51072 {
51073 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
51074 }
51075 {
51076 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
51077 }
51078 {
51079 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
51080 }
51081 {
51082 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
51083 }
51084 {
51085 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
51086 }
51087 {
51088 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
51089 }
51090 {
51091 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
51092 }
51093 {
51094 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
51095 }
51096 {
51097 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
51098 }
51099 {
51100 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
51101 }
51102 {
51103 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
51104 }
51105 {
51106 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
51107 }
51108 {
51109 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
51110 }
51111 {
51112 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
51113 }
51114 {
51115 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
51116 }
51117 {
51118 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
51119 }
51120 {
51121 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
51122 }
51123 {
51124 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
51125 }
51126 {
51127 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
51128 }
51129 {
51130 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51131 }
51132 {
51133 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51134 }
51135 {
51136 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51137 }
51138 {
51139 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51140 }
51141 {
51142 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51143 }
51144 {
51145 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51146 }
51147 {
51148 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51149 }
51150 {
51151 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51152 }
51153 {
51154 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51155 }
51156 {
51157 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51158 }
51159 {
51160 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51161 }
51162 {
51163 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51164 }
51165 {
51166 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51167 }
51168 {
51169 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51170 }
51171 {
51172 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51173 }
51174 {
51175 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51176 }
51177 {
51178 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51179 }
51180 {
51181 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51182 }
51183 {
51184 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51185 }
51186 {
51187 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51188 }
51189 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51190 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51191 {
51192 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51193 }
51194 {
51195 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51196 }
51197 {
51198 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51199 }
51200
51201 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51202
51203
51204 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51205
51206 {
51207 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51208 }
51209 {
51210 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51211 }
51212 {
51213 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51214 }
51215 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51216 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51217 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51218 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51219 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51220 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51221 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51222 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51223 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51224 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51225 {
51226 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51227 }
51228 {
51229 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51230 }
51231 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51232 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51233 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51234 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51235 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51236 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51237 {
51238 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51239 }
51240 {
51241 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51242 }
51243 {
51244 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51245 }
51246 {
51247 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51248 }
51249 {
51250 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51251 }
51252 {
51253 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51254 }
51255 {
51256 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51257 }
51258 {
51259 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51260 }
51261 {
51262 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51263 }
51264 {
51265 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51266 }
51267 {
51268 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51269 }
51270 {
51271 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51272 }
51273 {
51274 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51275 }
51276 {
51277 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51278 }
51279 {
51280 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51281 }
51282 {
51283 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51284 }
51285 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51286 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51287 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51288 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51289 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51290 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51291 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51292 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51293 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51294 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51295 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51296 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51297 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51298 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51299 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51300 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51301 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51302 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51303 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51304 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51305 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51306 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51307 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51308 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51309 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51310 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51311 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51312 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51313 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51314 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51315 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51316 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51317 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51318 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51319 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51320 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51321 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51322 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51323 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51324 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51325 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51326 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51327 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51328 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51329 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51330 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51331 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51332 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51333 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51334 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51335 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51336 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51337 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51338 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51339 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51340 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51341 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51342 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51343 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51344 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51345 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51346 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51347 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51348 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51349 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51350 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51351 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51352 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51353 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51354 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51355 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51356 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51357 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51358 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51359 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51360 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51361 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51362 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51363 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51364 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51365 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51366 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51367 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51368 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51369 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51370 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51371 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51372 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51373 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51374 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51375 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51376 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51377 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51378 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51379 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51380 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51381 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51382 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51383 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51384 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51385 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51386 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51387 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51388 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51389 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51390 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51391 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51392 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51393 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51394 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51395 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51396 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51397 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51398 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51399 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51400 {
51401 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51402 }
51403 {
51404 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51405 }
51406 {
51407 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51408 }
51409 {
51410 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51411 }
51412 {
51413 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51414 }
51415 {
51416 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51417 }
51418 {
51419 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51420 }
51421 {
51422 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51423 }
51424 {
51425 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51426 }
51427 {
51428 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51429 }
51430 {
51431 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51432 }
51433 {
51434 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51435 }
51436 {
51437 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51438 }
51439 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51440 {
51441 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51442 }
51443 {
51444 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51445 }
51446 {
51447 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51448 }
51449 {
51450 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51451 }
51452 {
51453 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51454 }
51455 {
51456 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51457 }
51458 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51459 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51460 {
51461 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51462 }
51463 {
51464 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51465 }
51466 {
51467 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51468 }
51469 {
51470 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51471 }
51472 {
51473 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51474 }
51475 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51476 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51477 {
51478 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51479 }
51480 {
51481 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51482 }
51483 {
51484 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51485 }
51486 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51487 {
51488 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51489 }
51490 {
51491 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51492 }
51493 {
51494 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51495 }
51496 {
51497 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51498 }
51499 {
51500 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51501 }
51502 {
51503 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51504 }
51505 {
51506 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51507 }
51508 {
51509 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51510 }
51511 {
51512 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51513 }
51514 {
51515 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51516 }
51517 {
51518 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51519 }
51520 {
51521 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51522 }
51523 {
51524 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51525 }
51526 {
51527 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51528 }
51529 {
51530 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51531 }
51532 {
51533 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51534 }
51535 {
51536 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51537 }
51538 {
51539 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51540 }
51541 {
51542 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51543 }
51544
51545 // Initialize threading, some globals and such
51546 __wxPyPreStart(d);
51547
51548
51549 // Although these are defined in __version__ they need to be here too so
51550 // that an assert can be done to ensure that the wxPython and the wxWindows
51551 // versions match.
51552 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51553 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51554 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51555
51556 }
51557
wxWidgets (Impactor)